home *** CD-ROM | disk | FTP | other *** search
/ Creative Computers / Creative Computers CD-ROM, Volume 1 (Legendary Design Technologies, Inc.)(1994).iso / shareware / fractals / ifslab / src / ifslab.c next >
C/C++ Source or Header  |  1994-11-17  |  119KB  |  3,134 lines
  1. /******************************************************************************\
  2. *                                                                              *
  3. *     IFS Lab, Copyright (C) 1992 by N. Zeldes. All rights reserved.           *
  4. *                                                                              *
  5. *                      Version 1.0, April 9, 1992                              *
  6. *                                                                              *
  7. *  An interactive program for exploring the IFS Code method of Fractal Image   *
  8. *  representation and reconstruction.                                          *
  9. *                                                                              *
  10. *  Requires the Fox/Dawson freeware req.library in libs: directory.            *
  11. *                                                                              *
  12. *  Compile under Aztec C 5.0, with -ff option (Fast floating point)            *
  13. *   and -safmnpsu options (code optimization).                                 *
  14. *  Link with +cd option (forces sprite and image data to load in CHIP RAM).    *
  15. *  Link with IFF files (from CBM IFF Disk, Fish disk #185), and with the glue  *
  16. *  module for the Fox/Dawson requester library, thus:                          *
  17. *                                                                              *
  18. *  cc  -ff -safmnpsu -i IFF -i req IFSLab.c                                    *
  19. *  ln  +cd IFSLab.o IFF/putpict.o IFF/ilbmw.o IFF/packer.o                     *
  20. *    IFF/iffw.o IFF/readpict.o IFF/ilbmr.o IFF/unpacker.o IFF/iffr.o           *
  21. *    IFF/remalloc.o req/myreqglue.o  mf.lib c.lib                              *
  22. *                                                                              *
  23. \******************************************************************************/
  24.  
  25. #include <intuition/intuition.h>
  26. #include <exec/memory.h> 
  27.         /* exec/memory.h required to use AllocMem() */
  28. #include <graphics/text.h>
  29.         /* graphics/text.h required for font TextAttr structure */
  30. #include <stdio.h>
  31. #include <math.h>    /* Floating point math: sqrt, fabs, trig functions */
  32. #include <errno.h>   /* Required by myatan2() */
  33. #include <graphics/display.h> /* needed for definition of INTERLACE */
  34. #include <stdlib.h>   /* stdlib.h needed for rand() */
  35. #include <time.h>     /* time.h needed for time() */
  36. #include <string.h>   /* needed for memset */
  37.  
  38. #include <ilbm.h>              /* Header file from IFF Disk (Note that   */
  39.                                /* ilbm.h #includes compiler.h and iff.h) */
  40. #include <readpict.h>          /* From IFF Disk */
  41. #include <remalloc.h>          /* From IFF Disk; For ChipAlloc(), RemFree() */
  42. #include <libraries/dos.h>     /* For IFF file I/O stuff */
  43. #include <libraries/dosextens.h> /* For the Process structure definition. */
  44. #include <reqbase.h>             /* Fox/Dawson file requester header file */
  45. #include "IFSLab.h"   /* PowerWindows-generated structures and defines */
  46.  
  47. #define INTUITION_REV 31L
  48. #define GRAPHICS_REV  31L
  49.  
  50. #define OUTLINE  0    /* parameters for SetMode() */
  51. #define COLLAGE  1
  52.  
  53. #define FREEHAND 0    /* drawmode values */
  54. #define LINES    1
  55. #define ERASE    2
  56. #define FILL     3
  57. #define VECTOR   4
  58.  
  59. #define CODES      0  /* parameters for AboutText() */
  60. #define IFS_THEORY 1
  61. #define HELP1      2
  62. #define HELP2      3
  63. #define AUTHOR     4
  64. #define DEMOTEXT   5
  65.  
  66. #define WIDTH   Window->Width
  67. #define HEIGHT  Window->Height
  68. #define GZZWIDTH   Window->GZZWidth
  69. #define GZZHEIGHT  Window->GZZHeight
  70.  
  71. #define MAX_N 19      /* max permitted piece index */
  72.  
  73. struct Screen *Screen = NULL, *ImageScreen;
  74. struct RastPort *scrp;     /* Pointer to Screen RastPort */
  75. struct Window *Window = NULL, *NumWindow;
  76. struct RastPort *r;  /* Pointer to RastPort of main editing window */
  77. struct Window *ImageWindow;  /* Window for rendering Image */
  78. struct RastPort *Textrp;   /* Rastport of Text Window */
  79. struct IntuitionBase *IntuitionBase = NULL;
  80. struct GfxBase *GfxBase = NULL;
  81. void *MathBase = NULL;
  82. void *MathTransBase = NULL;
  83. struct ReqLib *ReqBase = NULL;     /* Fox/Dawson Requester Library */
  84. int drawmode = FREEHAND;   
  85.   /* Current mode - FREEHAND,LINES,ERASE,FILL (outline) or VECTOR (Collage) */
  86. int exists_outline = 0, exists_image = 0, exists_numwindow = 0;
  87. int renderwidth = 640, renderheight = 400; /* initialize to default */
  88. int renderdepth = 1;  /* initialize to default */
  89. long mx, my;  /* Current Mouse coordinates in editing */
  90.  
  91. struct pixel {
  92.   long x;
  93.   long y;
  94. };
  95. struct piece {
  96.   double a, b, c, d, e, f;
  97.   double s1, s2, r1, r2;
  98.   double dens;
  99.   double p;
  100.   double det;
  101.   UBYTE *piecemap;
  102.   struct pixel boxo, boxx, boxy, boxz;
  103. };
  104. struct piece *pieceptr[MAX_N + 1]; /* Array of pointers to piece structures */
  105. int N = -1;   /* Index of highest existing Piece Initialized to zero pieces */
  106. int selpiece; /* Index of currently selected Piece */
  107. char curcor; /* Currently dragged Box corner ('o','x','y','z') or none ('0') */
  108. struct pixel ghboxo, ghboxx, ghboxy, ghboxz; /* Current corners of ghost Box */
  109. struct pixel tmpboxo, tmpboxx, tmpboxy, tmpboxz;
  110. struct piece *AllocPiece();
  111. double myatan2();  /* My version of atan2() which is missing in Manx mf.lib */
  112. char *fname, *GetFileName();
  113. struct Library *OpenLibrary();
  114. void *AllocMem(), *AllocRaster();
  115. UBYTE *outlinebufptr=NULL; /* ptr to buffer holding outline in collage mode */
  116. long i;      /* handy as a loop index */
  117.  
  118. /*** IFF error messages (external) */
  119.  
  120. char MsgOkay[] = { "(IFF_OKAY) A good IFF file" };
  121. char MsgEndMark[] = { "(END_MARK) IFF Loader Error" };
  122. char MsgDone[] = { "(IFF_DONE) Well Done!" };
  123. char MsgDos[] = { "DOS Error - Aborting Load!" };
  124. char MsgNot[] = { "Not an IFF file - Aborting Load!" };
  125. char MsgNoFile[] = { "No such file found - Aborting Load!" };
  126. char MsgClientError[] = { "(CLIENT_ERROR) IFF Checker bug"};
  127. char MsgForm[] = { "(BAD_FORM) IFF Loader Error" };
  128. char MsgShort[] = { "(SHORT_CHUNK) IFF Loader Error" };
  129. char MsgBad[] = { "A mangled IFF file - Aborting Load!" };
  130.  
  131. /* MUST GET THESE IN RIGHT ORDER!!*/
  132. char *IFFPMessages[-LAST_ERROR+1] = {
  133.     /*IFF_OKAY*/  MsgOkay,
  134.     /*END_MARK*/  MsgEndMark,
  135.     /*IFF_DONE*/  MsgDone,
  136.     /*DOS_ERROR*/ MsgDos,
  137.     /*NOT_IFF*/   MsgNot,
  138.     /*NO_FILE*/   MsgNoFile,
  139.     /*CLIENT_ERROR*/ MsgClientError,
  140.     /*BAD_FORM*/  MsgForm,
  141.     /*SHORT_CHUNK*/  MsgShort,
  142.     /*BAD_IFF*/   MsgBad
  143.     };
  144.  
  145. struct FileRequester MyFileReqStruct;    /* File Requester stuff */
  146. char filename[FCHARS+1];
  147. char directoryname[DSIZE+1];
  148. char pathname[FCHARS+DSIZE+2+4];  /* +4 to permit space for appending '.ifs' */
  149.  
  150. /*==========================================================================*/
  151.  
  152. main()
  153. {
  154.   struct Message * GetMsg();
  155.   void ReplyMsg();
  156.   struct IntuiMessage *message;
  157.   ULONG class;
  158.   USHORT code, MenuNumber, menuid, itemid, subitemid;
  159.   struct MenuItem *ItemAddress(), *ItemAddr;
  160.   long labs();
  161.   int w;  /* temporary int variable */
  162.   int hitgadget;  /* GadgetID # of last gadget hit by mouse */
  163.   struct Gadget *hitgadstruct; /* Gadget Structure of last hit gadget */
  164.   int numgadgpending;  /* GadgetID of unserviced coeff gadget, or -1 if none */
  165.   struct piece tmppiece;  /* will be used to hold temporary trans' coeffs */
  166.   long mx0,my0, mx1,my1;  /* coords of endpoints of ghost line in Lines mode */
  167.   int pendown = 0;
  168.              /* 0 if mouse SELECT button is currently pressed in window */
  169.   SHORT WindowBdrArray[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  170.              /* will be filled later to corners of inner GZZ Window */
  171.   struct Gadget *gad;  /* used as a temporary variable */
  172.  
  173.   /**** Initialize stuff, set up edit window in custom screen etc. ****/
  174.  
  175.   OpenLibraries();
  176.   OpenDisplay(); /* Open Outline Sketch  window in custom screen */
  177.  
  178.   SetAPen(r, 2L);
  179.   WindowBdrArray[2] = WindowBdrArray[4] = GZZWIDTH - 1;
  180.   WindowBdrArray[5] = WindowBdrArray[7] = GZZHEIGHT - 1;
  181.  
  182.   /*** Allocate memory for Outline buffer bitmap */
  183.   if ((outlinebufptr = 
  184.          (UBYTE *)AllocMem((long)RASSIZE(WIDTH,HEIGHT), MEMF_CHIP)) == NULL) {
  185.     ShowError("Can't allocate Outline Buffer Memory!");
  186.     CloseAll();
  187.   }
  188.        /**** Main Loop ****/
  189.  
  190.   while(1) {
  191.  
  192.       mx = (long)Window->GZZMouseX;
  193.       my = (long)Window->GZZMouseY;
  194.  
  195.     if (pendown == 1) {
  196.  
  197.      /*** Do Mouse editing to board per drawmode and mouse coords */
  198.       switch (drawmode) {
  199.  
  200.       case FREEHAND:
  201.         Draw(r, mx, my); 
  202.         break;
  203.  
  204.       case LINES:
  205.         SetDrMd(r, JAM1|COMPLEMENT);  /* COMPLEMENT used for ghost line */
  206.         Move(r, mx0, my0);
  207.         Draw(r, mx1,my1);   /* Undraw previous ghost line */
  208.         Move(r, mx0, my0);
  209.         Draw(r, mx1 = mx, my1 = my);  /* Draw a new ghost line */
  210.         SetDrMd(r, JAM1);
  211.         break;
  212.  
  213.       case ERASE:
  214.         RectFill(r, mx - 2, my - 2, mx + 2, my + 2);
  215.         break;
  216.  
  217.       case FILL:
  218.         break;
  219.  
  220.       case VECTOR:    /* Change the Ghost Vector Box */
  221.         if (exists_numwindow || curcor == '0')
  222.           break;
  223.  
  224.         /* Check for attempt to size box to a point */
  225.         if ( (mx==pieceptr[selpiece]->boxo.x && my==pieceptr[selpiece]->boxo.y)
  226.          &&  ( (curcor == 'z') || 
  227.                (curcor == 'x' && 
  228.                 pieceptr[selpiece]->boxy.x == pieceptr[selpiece]->boxo.x &&
  229.                 pieceptr[selpiece]->boxy.y == pieceptr[selpiece]->boxo.y) ||
  230.                (curcor == 'y' && 
  231.                 pieceptr[selpiece]->boxx.x == pieceptr[selpiece]->boxo.x &&
  232.                 pieceptr[selpiece]->boxx.y == pieceptr[selpiece]->boxo.y)
  233.               )
  234.         )
  235.           mx = (mx == 0) ? 1 : mx - 1; /* If attempted, tweak mx to avoid */
  236.  
  237.         ComputeNewBox();       /* Compute New Ghost Box from mouse coords */
  238.         ToggleGhostBox();      /* Undraw old ghost box */
  239.         ghboxo = tmpboxo;      /* Update ghost box variables */
  240.         ghboxx = tmpboxx;
  241.         ghboxy = tmpboxy;
  242.         ghboxz = tmpboxz;
  243.         ToggleGhostBox();      /* Draw new ghost box */
  244.         break;
  245.       }    /* End Switch */
  246.     }    /* end if pendown == 1 */
  247.  
  248.     /* Get an IDCMP event, if any, from Window */
  249.     if (message = (struct IntuiMessage *)GetMsg(Window->UserPort)) { 
  250.       class = message->Class;
  251.       code = message->Code;
  252.       ReplyMsg(message);
  253.     }
  254.     else  /* no message */
  255.       class = code = NULL; /* so event routines below will be skipped */
  256.  
  257.     /*** Go case by case over possible events from port */
  258.  
  259.     if (class == MOUSEBUTTONS) {    /*** Respond to user mousebutton clicks */
  260.       if (code == SELECTDOWN) {
  261.         pendown = 1;
  262.         if (drawmode != ERASE)
  263.           exists_outline = 1;
  264.         switch (drawmode) {
  265.  
  266.         case FREEHAND:
  267.         case ERASE:
  268.           Move(r, mx, my);
  269.           break;
  270.  
  271.         case LINES:
  272.           mx0 = mx1 = mx; /* Attach both ends of line to pixel */
  273.           my0 = my1 = my;
  274.           break;
  275.  
  276.         case FILL:
  277.           ModifyMousePtr(Window, 1);   /* Bring up 'ZZ' pointer */
  278.           SetAPen(r, 2L);
  279.           Move(r, 0L, 0L);
  280.           PolyDraw(r,5L,WindowBdrArray); /* temporary border to prevent */
  281.           Flood(r, 0L, mx, my);          /* messes on flood fill to edge */
  282.           SetAPen(r, 0L);
  283.           Move(r, 0L, 0L);
  284.           PolyDraw(r,5L,WindowBdrArray);
  285.           ModifyMousePtr(Window, -1);   /* Remove 'ZZ' pointer */
  286.           break;
  287.  
  288.         case VECTOR:
  289.           if (exists_numwindow)
  290.             break;
  291.           /*** Decide which corner, if any, the user clicked on */
  292.           curcor = '0';
  293.           w = selpiece;    /* Just to keep source lines shorter... */
  294.           if (labs(mx-pieceptr[w]->boxo.x)<5&&labs(my-pieceptr[w]->boxo.y)<5)
  295.             curcor = 'o';
  296.           if (labs(mx-pieceptr[w]->boxx.x)<5&&labs(my-pieceptr[w]->boxx.y)<5)
  297.             curcor = 'x';
  298.           if (labs(mx-pieceptr[w]->boxy.x)<5&&labs(my-pieceptr[w]->boxy.y)<5)
  299.             curcor = 'y';
  300.           if (labs(mx-pieceptr[w]->boxz.x)<5&&labs(my-pieceptr[w]->boxz.y)<5)
  301.             curcor = 'z';
  302.           if (curcor != '0') {     /* Set up ghost box for starters */
  303.  
  304.             /*** Update ghost box variables by calling ComputeNewBox() */
  305.             ComputeNewBox();
  306.             ghboxo = tmpboxo;               /* Structure Assignments */
  307.             ghboxx = tmpboxx;
  308.             ghboxy = tmpboxy;
  309.             ghboxz = tmpboxz;
  310.  
  311.             ToggleGhostBox();  /* Draw initial ghost box */
  312.           }
  313.           break;
  314.         }            /* End switch */
  315.       }       /* End if SELECTDOWN */
  316.  
  317.       else if (code == SELECTUP) {
  318.         pendown = 0;
  319.         switch (drawmode) {
  320.  
  321.         case FREEHAND:
  322.         case ERASE:
  323.         case FILL:
  324.           break;
  325.  
  326.         case LINES:
  327.           SetAPen(r, 2L);   /* Draw final line (Jam onto last Ghost line) */
  328.           Move(r,mx0, my0);
  329.           Draw(r, mx1, my1);
  330.           break;
  331.  
  332.         case VECTOR:
  333.           if (exists_numwindow || curcor == '0')
  334.             break;
  335.           ToggleGhostBox();  /* Undraw Ghost Box */
  336.           /*** Compute all coeffs from ghbox corners, put into tmppiece */
  337.           tmppiece = *pieceptr[selpiece];  /* Structure assignment */
  338.           tmppiece.s1 = 
  339.            sqrt((double)((ghboxx.x-ghboxo.x)*(ghboxx.x-ghboxo.x) +
  340.             (ghboxx.y-ghboxo.y)*(ghboxx.y-ghboxo.y)))/GZZWIDTH;
  341.           tmppiece.s2 = 
  342.            sqrt((double)((ghboxy.x-ghboxo.x)*(ghboxy.x-ghboxo.x) +
  343.             (ghboxy.y-ghboxo.y)*(ghboxy.y-ghboxo.y)))/GZZHEIGHT;
  344.           tmppiece.r1 = myatan2((double)(ghboxx.y-ghboxo.y),
  345.            (double)(ghboxx.x-ghboxo.x));
  346.           tmppiece.r2 = myatan2((double)(ghboxo.x-ghboxy.x),
  347.            (double)(ghboxy.y-ghboxo.y));
  348.           tmppiece.a = tmppiece.s1*cos(tmppiece.r1);
  349.           tmppiece.b = -tmppiece.s2*sin(tmppiece.r2);
  350.           tmppiece.c = tmppiece.s1*sin(tmppiece.r1);
  351.           tmppiece.d = tmppiece.s2*cos(tmppiece.r2);
  352.           tmppiece.e = (double)(ghboxo.x)/GZZWIDTH;
  353.           tmppiece.f = (double)(ghboxo.y)/GZZWIDTH;
  354.  
  355.           /*** Erase Plane 3 before transformation delay */
  356.           SetWrMsk(r,0xFFF8);  /* Write-protect planes 0,1,2 */
  357.           SetRast(r, 0L);
  358.           SetWrMsk(r,0xFFFF);
  359.           /* Transform the selected piece per user drag of vector box */
  360.           TransformPiece(outlinebufptr,
  361.                                    pieceptr[selpiece]->piecemap, &tmppiece);
  362.            /*** Erase Plane 2, then Blit Selected Piece from piecemap to it */
  363.           SetWrMsk(r,0xFFF4);  /* Write-protect planes 0,1,3 */
  364.           SetRast(r, 0L);
  365.           SetAPen(r, 4L);
  366.           BltTemplate((char*)pieceptr[selpiece]->piecemap,
  367.            (long)Window->BorderLeft,(long)WIDTH/8, r, 0L, 0L,
  368.              (long)GZZWIDTH, (long)GZZHEIGHT);
  369.           /* Rastport WrMask will be restored in DrawBox() called below */
  370.  
  371.           /*** Recompute probabilities and update piece structures */
  372.           tmppiece.boxo = ghboxo;  /* structure assignment */
  373.           tmppiece.boxx = ghboxx;  /* structure assignment */
  374.           tmppiece.boxy = ghboxy;  /* structure assignment */
  375.           tmppiece.boxz = ghboxz;  /* structure assignment */
  376.           *pieceptr[selpiece] = tmppiece;  /* structure assignment */
  377.           pieceptr[selpiece]->det = 
  378.            fabs(tmppiece.a * tmppiece.d - tmppiece.b * tmppiece.c);
  379.           if (pieceptr[selpiece]->det == 0.0)
  380.             pieceptr[selpiece]->det = 0.01;
  381.           ComputeProbs();      /* Adjust all piece probabilities */
  382.           DrawBox(); /* Redraw Vector Box for modified selected piece */
  383.           curcor = '0';
  384.           break;
  385.         }            /* End switch */
  386.       }              /* End else if SELECTUP */
  387.     }                /* End if MOUSEBUTTONS */
  388.  
  389.     else if (class == GADGETUP) {   /*** Respond to Gadget clicked in Window */
  390.  
  391.       hitgadget = ((struct Gadget *)(message->IAddress))->GadgetID;
  392.                                    /* ID# of just-selected gadget structure */
  393.       if (hitgadget <= 3)    /* a draw mode gadget in Outline mode */
  394.         HiliteGadget(hitgadget);
  395.       switch(hitgadget) {
  396.  
  397.       case 0:
  398.         drawmode = FREEHAND;
  399.         SetAPen(r,2L);
  400.         break;
  401.  
  402.       case 1:
  403.         drawmode = LINES;
  404.         SetAPen(r,2L);
  405.         break;
  406.  
  407.       case 2:
  408.         drawmode = ERASE;
  409.         SetAPen(r, 0L);
  410.         SetOPen(r, 0L);
  411.         break;
  412.  
  413.       case 3:
  414.         drawmode = FILL;
  415.         SetOPen(r, 2L);   /* (A Pen defined before doing the flood fill) */
  416.         break;
  417.  
  418.       case 4:             /* CLROUT (Clear Outline) gadget */
  419.         SetRast(r, 0L);
  420.         exists_outline = 0;
  421.         if(drawmode == ERASE || drawmode == FILL) {
  422.           drawmode = FREEHAND;
  423.           SetAPen(r,2L);
  424.           HiliteGadget(0);
  425.         }
  426.         break;
  427.  
  428.       case 5:             /* DONE gadget */
  429.         SetMode(COLLAGE);
  430.         AddDefPiece();
  431.         DrawCollage();
  432.         break;
  433.  
  434.       case 6:             /* ADD gadget */
  435.         AddDefPiece();
  436.         DrawCollage();
  437.         if (exists_numwindow)
  438.           UpdateNumStrings();
  439.         break;
  440.  
  441.       case 7:             /* DUP gadget */
  442.         DupSelPiece();
  443.         DrawCollage();
  444.         if (exists_numwindow)
  445.           UpdateNumStrings();
  446.         break;
  447.  
  448.       case 8:             /* SELECT gadget */
  449.         if (--selpiece < 0)
  450.           selpiece = N;
  451.         DrawCollage();
  452.         if (exists_numwindow)
  453.           UpdateNumStrings();
  454.         break;
  455.  
  456.       case 9:             /* DELETE gadget */
  457.         DeleteSelPiece();
  458.         DrawCollage();
  459.         ComputeProbs();
  460.         if (exists_numwindow)
  461.           UpdateNumStrings();
  462.         break;
  463.  
  464.       case 10:            /* CLRIFS gadget */
  465.         ClearIFS();
  466.         AddDefPiece();
  467.         DrawCollage();
  468.         if (exists_numwindow)
  469.           UpdateNumStrings();
  470.         break;
  471.  
  472.       case 11:            /* NUMBERS Gadget */
  473.         if (!exists_numwindow) {
  474.           UpdateNumStrings();
  475.           OpenNumWindow();
  476.           numgadgpending = -1;
  477.         }
  478.  
  479.         break;
  480.       }   /* end switch hitgadget */
  481.     }     /* End else if GADGETUP */
  482.  
  483.     else if (class == MENUPICK) {     /*** Respond to menu selections */
  484.  
  485.       MenuNumber = code;         /* (First) item selection returned by IDCMP */
  486.       while (MenuNumber != MENUNULL) { /*** service multiply chosen items */
  487.                                        /* (if any) */
  488.         ItemAddr = ItemAddress(&MenuList1, (long)MenuNumber);
  489.        
  490.         menuid = MENUNUM(MenuNumber); /* Extract menu, item from IDCMP code */
  491.         itemid = ITEMNUM(MenuNumber);
  492.         subitemid = SUBNUM(MenuNumber);
  493.  
  494.         if (menuid == 0) {   /* PROJECT Menu */
  495.           switch (itemid) {
  496.  
  497.           case 0:            /* NEW */
  498.             if (SetMode(OUTLINE) == 1) {
  499.               SetRast(r, 0L);
  500.               exists_outline = 0;
  501.               if (exists_image)
  502.                 CloseImageScreen();
  503.             }
  504.             break;
  505.  
  506.           case 1:            /* EDIT OUTLINE */
  507.             SetMode(OUTLINE);
  508.             break;
  509.  
  510.           case 2:            /* LOAD FILE (with subitems) */
  511.             if(ReqBase == NULL) {    /* req.library missing - no file I/O */
  512.               ShowError("req.library not found!");
  513.               break;
  514.             }
  515.             fname = GetFileName("File to Load:");
  516.             if (*fname != '\0') {
  517.  
  518.               switch (subitemid) {
  519.  
  520.               case 0:    /* Load Outline */
  521.                 if (SetMode(OUTLINE) == 1)
  522.                   LoadILBM(fname, 0);
  523.                 break;
  524.  
  525.               case 1:    /* Load IFS */
  526.                 SetMode(COLLAGE);
  527.                 if (LoadIFS(fname) == NULL) {  /* If load failed */
  528.                   ClearIFS();
  529.                   AddDefPiece();
  530.                   DrawCollage();
  531.                 }
  532.                 break;
  533.  
  534.               case 2:    /* Load Image */
  535.                 LoadILBM(fname, 1);
  536.                 break;
  537.               }    /* end switch subitemid */
  538.             }      /* end if *fname etc */
  539.             break;
  540.  
  541.           case 3:            /* SAVE FILE (with subitems) */
  542.             if(ReqBase == NULL) {    /* req.library missing - no file I/O */
  543.               ShowError("req.library not found!");
  544.               break;
  545.             }
  546.             switch (subitemid) {
  547.  
  548.             case 0:    /* Save IFS */
  549.               SaveIFS();
  550.               break;
  551.  
  552.             case 1:    /* Save Image */
  553.               SaveILBM();
  554.               break;
  555.             }    /* end switch subitemid */
  556.             break;
  557.  
  558.           case 4:            /* OPTIMIZE */
  559.             if (drawmode != VECTOR)
  560.               ShowError("No IFS to Optimize!");
  561.             else
  562.               Optimize(1);
  563.             break;
  564.  
  565.           case 5:            /* QUIT */
  566.             CloseAll();
  567.             break;
  568.           }   /* end switch itemid */
  569.         }     /* end if menuid == 0) */
  570.  
  571.         else if (menuid == 1) {   /* DISPLAY Menu */
  572.           switch (itemid) {
  573.  
  574.           case 0:            /* SHOW CODES */
  575.             if (drawmode != VECTOR)
  576.               ShowError("No IFS!");
  577.             else
  578.               AboutText(CODES); 
  579.             break;
  580.  
  581.           case 1:            /* SHOW IMAGE */
  582.             if (exists_image) {
  583.               MoveScreen(ImageScreen, 0L, (long)(-1*ImageScreen->TopEdge));
  584.               ScreenToFront(ImageScreen);
  585.             }
  586.             else
  587.               ShowError("No Image!");
  588.             break;
  589.           }   /* end switch itemid */
  590.         }     /* end else if menuid == 1) */
  591.  
  592.         else if (menuid == 2) {   /* RENDER Menu */
  593.           switch (itemid) {
  594.  
  595.           case 0:            /* RESOLUTION (with subitems) */
  596.             renderwidth = (subitemid > 0) ? 640 : 320;
  597.             renderheight = (subitemid > 1) ? 400 : 200;
  598.             break;
  599.  
  600.           case 1:            /* GRAY LEVELS (with subitems) */
  601.             renderdepth = subitemid + 1;
  602.             break;
  603.  
  604.           case 2:            /* START */
  605.             while(message = (struct IntuiMessage *)GetMsg(Window->UserPort)) 
  606.               ReplyMsg(message);  /* Clean out IDCMP port before closing it */
  607.             ModifyIDCMP(Window, NULL);   /* Disable IDCMP during rendering */
  608.             ClearMenuStrip(Window); /* remove main window menus during render*/
  609.             RenderImage(0);     /* render the attractor in Image Screen */
  610.             SetMenuStrip(Window, &MenuList1);
  611.             ModifyIDCMP(Window, MOUSEBUTTONS|GADGETUP|MENUPICK);
  612.             break;
  613.           }   /* end switch itemid */
  614.         }     /* end else if menuid == 2) */
  615.  
  616.         else if (menuid == 3) {   /* ABOUT Menu */
  617.           switch (itemid) {
  618.  
  619.           case 0:            /* IFS THEORY */
  620.             AboutText(IFS_THEORY);
  621.             break;
  622.  
  623.           case 1:            /* HELP */
  624.             AboutText(HELP1);
  625.             AboutText(HELP2);
  626.             break;
  627.  
  628.           case 2:            /* AUTHOR */
  629.             AboutText(AUTHOR);
  630.             break;
  631.  
  632.           case 3:            /* DEMO */
  633.             DoDemo();
  634.             break;
  635.           }   /* end switch itemid */
  636.         }     /* end else if menuid == 3) */
  637.  
  638.         MenuNumber = ItemAddr->NextSelect; 
  639.                       /* Loop back for next multiply selected item, if any */       
  640.       }   /* end while MenuNumber != MENUNULL */
  641.     }     /* end else if MENUPICK */
  642.  
  643.     /*** Get & serve an IDCMP event, if any, from Coefficients Window */
  644.  
  645.     if (exists_numwindow) {
  646.       if (message = (struct IntuiMessage *)GetMsg(NumWindow->UserPort)) { 
  647.         ReplyMsg(message);
  648.  
  649.         /* Note that all events in this window are GADGETUP, GADGETDOWN */
  650.         /* or CLOSEWINDOW */
  651.  
  652.         if (message->Class == CLOSEWINDOW) {
  653.           CloseWindow(NumWindow);
  654.           exists_numwindow = 0;
  655.           numgadgpending = -1;
  656.           SetMenuStrip(Window, &MenuList1);
  657.         }
  658.         else if (message->Class == GADGETDOWN) {  /* ENTER or string gadget */
  659.           if (numgadgpending != -1)
  660.             RecomputeCoeffs(numgadgpending);
  661.           hitgadstruct = (struct Gadget *)(message->IAddress);
  662.                                                /* pointer to just-hit gadget */
  663.           numgadgpending = hitgadstruct->GadgetID;
  664.                                    /* ID# of just-selected gadget structure */
  665.  
  666.           /**** Refresh all string gadgets except just-hit one  */
  667.           for(gad = &NumAcoeffGadg; gad != NULL; gad = gad->NextGadget)
  668.             if (gad->GadgetID != numgadgpending)
  669.               RefreshGList(gad, NumWindow, NULL, 1L);
  670.           if (numgadgpending == 12)
  671.             numgadgpending = -1;     /* It was only the ENTER Gadget */
  672.         }
  673.         else if (message->Class == GADGETUP) {
  674.           hitgadget = ((struct Gadget *)(message->IAddress))->GadgetID;
  675.                                    /* ID# of just-selected gadget structure */
  676.           switch (hitgadget) {
  677.  
  678.           case 12:       /* ENTER */
  679.  
  680.             tmppiece = *pieceptr[selpiece];  /* Structure assignment */
  681.  
  682.             /* Copy all coeffs from string gadgets to tmppiece */
  683.  
  684.             sscanf((char*)NumNumR2coeffGadgSIBuff, "%lf", &tmppiece.r2);
  685.             sscanf((char*)NumNumR1coeffGadgSIBuff, "%lf", &tmppiece.r1);
  686.             sscanf((char*)NumNumS2coeffGadgSIBuff, "%lf", &tmppiece.s2);
  687.             sscanf((char*)NumNumS1coeffGadgSIBuff, "%lf", &tmppiece.s1);
  688.             sscanf((char*)NumNumPcoeffGadgSIBuff, "%lf", &tmppiece.p);
  689.             sscanf((char*)NumNumDenscoeffGadgSIBuff, "%lf",
  690.                                                    &tmppiece.dens);
  691.             sscanf((char*)NumNumFcoeffGadgSIBuff, "%lf", &tmppiece.f);
  692.             sscanf((char*)NumNumEcoeffGadgSIBuff, "%lf", &tmppiece.e);
  693.             sscanf((char*)NumNumDcoeffGadgSIBuff, "%lf", &tmppiece.d);
  694.             sscanf((char*)NumNumCcoeffGadgSIBuff, "%lf", &tmppiece.c);
  695.             sscanf((char*)NumNumBcoeffGadgSIBuff, "%lf", &tmppiece.b);
  696.             sscanf((char*)NumNumAcoeffGadgSIBuff, "%lf", &tmppiece.a);
  697.  
  698.             tmppiece.r1 = tmppiece.r1*0.017453293; /* convert degs to radians*/
  699.             tmppiece.r2 = tmppiece.r2*0.017453293;
  700.  
  701.             /*** Erase Plane 3 before transformation delay */
  702.             SetWrMsk(r,0xFFF8);  /* Write-protect planes 0,1,2 */
  703.             SetRast(r, 0L);
  704.             SetWrMsk(r, 0xFFFF);
  705.  
  706.             /* Transform the selected piece per user-entered coefficients */
  707.             TransformPiece(outlinebufptr,
  708.                                pieceptr[selpiece]->piecemap, &tmppiece);
  709.             /*** Erase Plane 2, then Blit Selected Piece from piecemap to it */
  710.             SetWrMsk(r,0xFFF4);  /* Write-protect planes 0,1,3 */
  711.             SetRast(r, 0L);
  712.             SetAPen(r, 4L);
  713.             BltTemplate((char*)pieceptr[selpiece]->piecemap,
  714.              (long)Window->BorderLeft,(long)WIDTH/8, r, 0L, 0L,
  715.               (long)GZZWIDTH, (long)GZZHEIGHT);
  716.             /* Rastport WrMask will be restored in DrawBox() called below */
  717.  
  718.             /*** Compute new Box corners from new coeffs */
  719.             tmppiece.boxo.x = tmppiece.e * GZZWIDTH;
  720.             tmppiece.boxo.y = tmppiece.f * GZZWIDTH; /* sic! */
  721.             tmppiece.boxx.x = (tmppiece.a + tmppiece.e) * GZZWIDTH;
  722.             tmppiece.boxx.y = (tmppiece.c + tmppiece.f) * GZZWIDTH;
  723.             tmppiece.boxy.x = (tmppiece.b*GZZHEIGHT/GZZWIDTH + tmppiece.e) *
  724.                                GZZWIDTH;
  725.             tmppiece.boxy.y = (tmppiece.d*GZZHEIGHT/GZZWIDTH + tmppiece.f) *
  726.                                GZZWIDTH;
  727.             tmppiece.boxz.x = 
  728.                        tmppiece.boxy.x + tmppiece.boxx.x - tmppiece.boxo.x;
  729.             tmppiece.boxz.y = 
  730.                        tmppiece.boxy.y + tmppiece.boxx.y - tmppiece.boxo.y;
  731.  
  732.             *pieceptr[selpiece] = tmppiece;  /* structure assignment */
  733.             /*** Recompute probabilities and update piece structures */
  734.             pieceptr[selpiece]->det = 
  735.              fabs(tmppiece.a * tmppiece.d - tmppiece.b * tmppiece.c);
  736.             if (pieceptr[selpiece]->det == 0.0)
  737.               pieceptr[selpiece]->det = 0.01;
  738.             ComputeProbs();      /* Adjust all piece probabilities */
  739.             DrawBox(); /* Redraw Vector Box for modified selected piece */
  740.             break;
  741.  
  742.           default:       /* GADGETUP on any coefficient string gadget */              
  743.             numgadgpending = -1;
  744.             RecomputeCoeffs(hitgadget);
  745.             RefreshGadgets(&NumGadgetList3, NumWindow, NULL);
  746.             break;
  747.           }  /* end switch hitgadget */
  748.         }    /* end else if ... GADGETUP */
  749.       }      /* end if message etc of coeffs window */
  750.     }        /* end if exists_numwindow */
  751.  
  752.     /*** Get & serve an IDCMP event, if any, from Image Window */
  753.     /*   Note that all events in this window are MOUSEBUTTONS  */
  754.  
  755.     if (exists_image) {
  756.       if (message = (struct IntuiMessage *)GetMsg(ImageWindow->UserPort)) { 
  757.         ReplyMsg(message);
  758.         if (message->Code == SELECTUP) { /* User clicked - push Image to back*/
  759.           ScreenToBack(ImageScreen);
  760.           MoveScreen(ImageScreen, 0L, (long)(-1*ImageScreen->TopEdge));
  761.           ScreenToFront(Screen);
  762.           ActivateWindow(Window);
  763.         }
  764.       }
  765.     }        /* End if exists_image */
  766.   }          /* End while of main loop */
  767. }            /* End main() */
  768. /*=========================================================================*/
  769.  
  770. char * GetFileName(prompt)    /* Returns pointer to a filename selected from */
  771. char *prompt;        /* a file requester. Prompt appears at top of requester */
  772.                      /* window. If user selected CANCEL,returns a nullstring */
  773.                      /* Places the requester in a custom 640x200 screen.     */
  774.  
  775.                      /* Uses the Fox/Dawson File Requester; you must link    */
  776.                      /* with glue module myreqglue.o. You need to include    */
  777.                      /* reqbase.h and also libraries/dosextens.h (for the    */
  778.                      /* Process structure).                                  */
  779. {
  780.   struct Screen *ReqScreen;
  781.   struct Window *ReqWindow;
  782.   struct NewScreen ns;
  783.   struct Screen *OpenScreen();
  784.   struct NewWindow nw;
  785.   struct Window *OpenWindow();
  786.  
  787.   struct Task *FindTask();
  788.   struct Process *myprocess;
  789.   APTR oldwindowptr;
  790.  
  791.   /* Link the buffers to the FileRequester struct (all declared as globals) */
  792.  
  793.   MyFileReqStruct.File = filename;
  794.   MyFileReqStruct.Dir = directoryname;
  795.   MyFileReqStruct.PathName = pathname;
  796.  
  797.   /*** Open a window in a custom Hires screen for requester display */
  798.  
  799.   ns.LeftEdge = 0;      /*** Initialize a NewScreen structure */
  800.   ns.TopEdge = 0;
  801.   ns.Width = 640;
  802.   ns.Height = 200;
  803.   ns.Depth = 2;
  804.   ns.DetailPen = 0;  /* Colour of text in screen title bar */
  805.   ns.BlockPen = 1;   /* Colour of screen Title Bar */
  806.   ns.ViewModes = HIRES;
  807.   ns.Type = CUSTOMSCREEN;
  808.   ns.Font = &TOPAZ80;
  809.   ns.DefaultTitle = NULL;
  810.   ns.Gadgets = NULL;
  811.   ns.CustomBitMap = NULL;
  812.  
  813.   nw.LeftEdge = 0;         /*** Initialize a NewWindow structure */
  814.   nw.TopEdge = 0;
  815.   nw.Width = 640;
  816.   nw.Height = 200;
  817.   nw.DetailPen = 0; /* Menu title text color */
  818.   nw.BlockPen  = 1; /* Menu item box and title bar background */
  819.   nw.IDCMPFlags = NULL;
  820.   nw.Flags = ACTIVATE|NOCAREREFRESH;
  821.   nw.FirstGadget = NULL;
  822.   nw.CheckMark = NULL;
  823.   nw.Title = (UBYTE*)" ";
  824.   nw.Screen = NULL;  /* Will set it to ReqScreen after the screen is opened */
  825.   nw.BitMap = NULL;
  826.   nw.MinWidth = 0;
  827.   nw.MinHeight = 0;
  828.   nw.MaxWidth = 0;
  829.   nw.MaxHeight = 0;
  830.   nw.Type = CUSTOMSCREEN;
  831.  
  832.  
  833.   /*** Open a Hires screen to place the requester in */
  834.  
  835.   if ((ReqScreen = (struct Screen *) OpenScreen(&ns)) == NULL) {
  836.     ShowError("Couldn't open Requester screen!!!");
  837.     pathname[0] = '\0'; /* make returned buffer a nullstring */
  838.     return(pathname);
  839.   }
  840.  
  841.   /*** Open the Window to place the requester in */
  842.   nw.Screen = ReqScreen;
  843.   if ((ReqWindow = (struct Window *) OpenWindow(&nw)) == NULL) {
  844.     CloseScreen(ReqScreen);
  845.     ShowError("Couldn't open Requester window!!!");
  846.     pathname[0] = '\0'; /* make returned buffer a nullstring */
  847.     return(pathname);
  848.   }  
  849.  
  850.   /* Set pointer to tell req.library requesters where to appear */
  851.   myprocess = (struct Process *)FindTask((char *)0);
  852.   oldwindowptr = myprocess->pr_WindowPtr;
  853.   myprocess->pr_WindowPtr = (APTR)ReqWindow;
  854.  
  855.   /*** Set up file requester structure fields to customize requester */
  856.  
  857.   MyFileReqStruct.Title = prompt;    /* Text at top of requester */
  858.   MyFileReqStruct.dirnamescolor = 3; /* colours of requester elements */
  859.   MyFileReqStruct.devicenamescolor = 3;
  860.   MyFileReqStruct.WindowLeftEdge = 0;
  861.   MyFileReqStruct.WindowTopEdge = 0;
  862.   MyFileReqStruct.Flags = FRQCACHINGM |    /* Directory Caching */
  863.                        FRQABSOLUTEXYM | /* Fix requester position in screen  */
  864.                        FRQNOHALFCACHEM| /* Don't cache half-read directories */
  865.                        FRQNODRAGM;      /* No drag bar on requester */
  866.  
  867.   if (FileRequester(&MyFileReqStruct) == NULL)   /* Call the File Requester */
  868.     pathname[0] = '\0'; /* If user selected no file, return a nullstring*/
  869.  
  870.   /* restore pr_WindowPtr before closing the window! */
  871.   myprocess->pr_WindowPtr = oldwindowptr;
  872.  
  873.   CloseWindow(ReqWindow);   /*** Close requester screen stuff and return */
  874.   CloseScreen(ReqScreen);
  875.  
  876.   return(pathname); /* Will be the pointer to a string which now contains the */
  877.                     /* full file name selected, or a NULL string if the user */
  878.                     /* selected CANCEL or no filename */
  879. }
  880. /*===========================================================================*/
  881.  
  882. OpenLibraries()     /* Open needed libraries */
  883. {
  884.   IntuitionBase = (struct IntuitionBase *)
  885.           OpenLibrary("intuition.library",INTUITION_REV);
  886.   if (IntuitionBase == NULL) {
  887.     printf("Can't open Intuition library!!!!!!\n");
  888.     CloseAll();
  889.   }
  890.  
  891.   GfxBase = (struct GfxBase *)
  892.           OpenLibrary("graphics.library",GRAPHICS_REV);
  893.   if (GfxBase == NULL) {
  894.     printf("Can't open graphics library!!!!!!\n");
  895.     CloseAll();
  896.   }
  897.  
  898.   MathBase = (void *)OpenLibrary("mathffp.library",0L);
  899.   if (MathBase == NULL) {
  900.     printf("Can't open mathffp library!!!!!!\n");
  901.     CloseAll();
  902.   }
  903.  
  904.   MathTransBase = (void *)OpenLibrary("mathtrans.library",0L);
  905.   if (MathTransBase == NULL) {
  906.     printf("Can't open mathtrans library!!!!!!\n");
  907.     CloseAll();
  908.   }
  909.   ReqBase = (struct ReqLib *)OpenLibrary("req.library", 0L);
  910.   if (ReqBase == NULL) {
  911.     printf("Couldn't open req.library!!!!!!\n");
  912.     printf("IFSlab requires req.library in libs: to be able to do file I/O\n");
  913.   }
  914. }
  915. /*=========================================================================*/
  916.  
  917. OpenDisplay()   /* Open Outline Sketch window in custom screen */
  918.  
  919. {
  920.   /* NEWSCREENSTRUCTURE, PALETTE and NewWindowStructure1 are in IFSLab.h */
  921.   /* and, along with pointers Window, Screen, have been declared externally */
  922.  
  923.   struct Screen *OpenScreen();
  924.   struct Window *OpenWindow();
  925.   struct ViewPort *vp;
  926.  
  927.   /*** Open the screen */
  928.   if ((Screen = (struct Screen *) OpenScreen(&NEWSCREENSTRUCTURE)) == NULL) {
  929.     printf("\nCouldn't open screen!!!!\n");
  930.     CloseAll();
  931.   }
  932.   /*** Link Custom colours defined in PALETTE to screen's ViewPort */  
  933.   vp = &(Screen->ViewPort);/* ptr to viewport structure assoc'd with screen */
  934.   LoadRGB4(vp,PALETTE,16L);   /* Change to custom colors defined above */
  935.  
  936.   /*** Open the Window */
  937.  
  938.   NewWindowStructure1.Screen = Screen;
  939.   if ((Window =  (struct Window *) OpenWindow(&NewWindowStructure1)) == NULL) {
  940.     printf("\nCouldn't open window!!!!\n");
  941.     CloseAll();
  942.   }
  943.  
  944.   scrp = &(Screen->RastPort); /* Screen RastPort,used to draw in outer window*/
  945.   SetDrMd(scrp, JAM1);
  946.   SetAPen(scrp, 1L);
  947.   r = (Window->RPort);  /* Window's rastport, used for drawing in GZZ bitmap */
  948.   SetDrMd(r, JAM1);
  949.   HiliteGadget(0);
  950.   SetMenuStrip(Window,&MenuList1);
  951.   OffMenu(Window, NOITEM<<5 | 2);     /* disable render menu and its items */
  952. }
  953. /*===========================================================================*/
  954.  
  955. OpenNumWindow()   /* Open Coefficients Window and disable menus */
  956. { 
  957.   /* Assumes window is not open already */
  958.  
  959.   NumNewWindowStructure3.Screen = Screen;
  960.   if ((NumWindow = (struct Window *)OpenWindow(&NumNewWindowStructure3))
  961.                                                                  == NULL) {
  962.     ShowError("Error - Couldn't open coeffs window");
  963.     return;
  964.   }
  965.   ClearMenuStrip(Window); /* remove main window menus while Coeffs window on */
  966.   SetWindowTitles(NumWindow, -1L, (char *)"           Collage Editor");
  967.   exists_numwindow = 1;
  968. }
  969. /*===========================================================================*/
  970.  
  971. CloseAll()    /* Close everything neatly and exit program */
  972. {
  973.   if (exists_image)
  974.     CloseImageScreen();
  975.   for (i = 0; i <= N; i++)  /* Dealocate Pieces' struct and piecemap memory */
  976.     FreePiece(pieceptr[i]);
  977.   if (outlinebufptr)
  978.     FreeMem(outlinebufptr, (long)RASSIZE(WIDTH, HEIGHT));
  979.   if (Window) {
  980.     ClearMenuStrip(Window);
  981.     CloseWindow(Window);
  982.   }
  983.   if (exists_numwindow)
  984.     CloseWindow(NumWindow);
  985.   if (Screen)
  986.     CloseScreen(Screen);
  987.   if (IntuitionBase)
  988.     CloseLibrary(IntuitionBase);
  989.   if (GfxBase)
  990.     CloseLibrary(GfxBase);
  991.   if (MathBase)
  992.     CloseLibrary(MathBase);
  993.   if (MathTransBase)
  994.     CloseLibrary(MathTransBase);
  995.   if (ReqBase) {
  996.     PurgeFiles(&MyFileReqStruct);    /* function in req.library */
  997.     CloseLibrary(ReqBase);
  998.   }
  999.  
  1000.   exit(0);
  1001. }
  1002. /*===========================================================================*/
  1003.  
  1004. int SetMode(newmode)   /* Sets up and enters requested mode */
  1005. int newmode;           /* newmode can be OUTLINE or COLLAGE */
  1006. {                   /* returns 1 normally; returns 0 if user chose CANCEL in */
  1007.                     /* "IFS will be LOST" requester */
  1008.   BOOL AutoRequest();
  1009.   static  struct IntuiText Cancel = {
  1010.     3,0,                 /* FrontPen, BackPen */
  1011.     JAM1,                /* DrawMode */
  1012.     6,3,                 /* LeftEdge, TopEdge */
  1013.     &TOPAZ80,            /* ITextFont */
  1014.     (UBYTE*)"Cancel",    /* IText */
  1015.     NULL                 /* NextText */
  1016.   };
  1017.   static struct IntuiText Doit, ReqBodyText;
  1018.   Doit = ReqBodyText = Cancel;  /* structure assignment */
  1019.   ReqBodyText.IText = (UBYTE *)" IFS will be LOST!";
  1020.   ReqBodyText.TopEdge = 8;
  1021.   Doit.IText = (UBYTE *)"Do it!";
  1022.  
  1023.   switch (newmode) {
  1024.  
  1025.   case OUTLINE:
  1026.     if (drawmode != VECTOR)     /* already in desired mode! */
  1027.       return(1);
  1028.     if (AutoRequest(Window, &ReqBodyText, &Doit, &Cancel, 
  1029.                           NULL, NULL, 180L, 56L) == FALSE)  {
  1030.       /* Set IDCMP flags right in case AutoRequest() messed 'em up */
  1031.       ModifyIDCMP(Window, MOUSEBUTTONS|GADGETUP|MENUPICK);
  1032.       return(0);
  1033.     }
  1034.     ModifyIDCMP(Window, MOUSEBUTTONS|GADGETUP|MENUPICK); /* After AutoReq. */
  1035.     ClearIFS();
  1036.     RemoveGList(Window, &CollageGadgetList2, 6L);
  1037.     AddGList(Window, &GadgetList1, 0L, 6L, NULL); /* change gadgets */
  1038.     SetDrMd(scrp, JAM1);
  1039.     SetAPen(scrp, 0L);
  1040.     RectFill(scrp, 280L, 12L, 316L, 117L); /* Blot out old gadget images */
  1041.     RefreshGadgets(&GadgetList1, Window, NULL);
  1042.     OffMenu(Window, NOITEM<<5 | 2);     /* disable render menu and its items */
  1043.     SetWindowTitles(Window, -1L, "           Outline Editor");
  1044.     drawmode = FREEHAND;
  1045.     HiliteGadget(0);
  1046.     SetAPen(r, 2L);
  1047.     break;
  1048.  
  1049.   case COLLAGE:
  1050.     if (drawmode == VECTOR)     /* already in desired mode! */
  1051.       return(1);
  1052.     if (exists_outline == 0)
  1053.       PutDefOutline();
  1054.  
  1055.     CopyMem((char*)Window->RPort->BitMap->Planes[1], 
  1056.       (char*)outlinebufptr, (long)RASSIZE(WIDTH,HEIGHT));
  1057.  
  1058.     RemoveGList(Window, &GadgetList1, 6L);
  1059.     AddGList(Window, &CollageGadgetList2, 0L, 6L, NULL);
  1060.     SetDrMd(scrp, JAM1);
  1061.     SetAPen(scrp, 0L);
  1062.     RectFill(scrp, 280L, 12L, 316L, 117L); /* Blot out old gadget images */
  1063.     RefreshGadgets(&CollageGadgetList2, Window, NULL);
  1064.     OnMenu(Window, NOITEM<<5 | 2);     /* Enable render menu and its items */
  1065.     SetWindowTitles(Window, -1L, "           Collage Editor");
  1066.     drawmode = VECTOR;
  1067.     curcor = '0';
  1068.     break;
  1069.   }    /* end switch newmode */
  1070.   return(1);
  1071. }
  1072. /*===========================================================================*/
  1073.  
  1074. DupSelPiece()       /* Generate a copy of Selected Piece, make it highest */
  1075. {                   /* numbered and Selected. Increment N. */
  1076.   if (N >= MAX_N) {
  1077.     ShowError("Too many transformations");
  1078.     return;
  1079.   }
  1080.   /*** Allocate and fill piece structure, make it Selected */
  1081.  
  1082.   if ((pieceptr[++N] = AllocPiece()) == NULL) {  /* Allocate Piece */
  1083.     N--;         /* if couldn't allocate piece */
  1084.     if (N == -1) {    /* No memory for even one Piece - Quit program */
  1085.       ShowError("Re-run with more free memory!");
  1086.       CloseAll();
  1087.     }
  1088.     return;
  1089.   }
  1090.   pieceptr[N]->a = pieceptr[selpiece]->a;
  1091.   pieceptr[N]->b = pieceptr[selpiece]->b;
  1092.   pieceptr[N]->c = pieceptr[selpiece]->c;
  1093.   pieceptr[N]->d = pieceptr[selpiece]->d;
  1094.   pieceptr[N]->e = pieceptr[selpiece]->e;
  1095.   pieceptr[N]->f = pieceptr[selpiece]->f;
  1096.   pieceptr[N]->s1 = pieceptr[selpiece]->s1;
  1097.   pieceptr[N]->s2 = pieceptr[selpiece]->s2;
  1098.   pieceptr[N]->r1 = pieceptr[selpiece]->r1;
  1099.   pieceptr[N]->r2 = pieceptr[selpiece]->r2;
  1100.   pieceptr[N]->dens = 1.0;
  1101.   pieceptr[N]->det = pieceptr[selpiece]->det;
  1102.   pieceptr[N]->boxo = pieceptr[selpiece]->boxo;  /* Structure assignment! */
  1103.   pieceptr[N]->boxx = pieceptr[selpiece]->boxx;  /* Structure assignment! */
  1104.   pieceptr[N]->boxy = pieceptr[selpiece]->boxy;  /* Structure assignment! */
  1105.   pieceptr[N]->boxz = pieceptr[selpiece]->boxz;  /* Structure assignment! */
  1106.  
  1107.   ComputeProbs();  /* Adjust all Piece probabilities */
  1108.   /* Copy selected piece's piecemap to the new piece's piecemap */
  1109.   CopyMem((char*)pieceptr[selpiece]->piecemap, (char*)pieceptr[N]->piecemap,
  1110.                                               (long)RASSIZE(WIDTH,GZZHEIGHT));
  1111.   selpiece = N;   /* make this Piece Selected */
  1112. }
  1113. /*===========================================================================*/
  1114.  
  1115. AddDefPiece()       /* Generate a default Piece of current Outline, make */
  1116. {                   /* it highest numbered and Selected. Increment N. */
  1117.   if (N >= MAX_N) {
  1118.     ShowError("Too many transformations");
  1119.     return;
  1120.   }
  1121.   /*** Allocate and fill piece structure, make it Selected */
  1122.  
  1123.   if ((pieceptr[++N] = AllocPiece()) == NULL) {  /* Allocate Piece */
  1124.     N--;         /* if couldn't allocate piece */
  1125.     if (N == -1) {    /* No memory for even one Piece - Quit program */
  1126.       ShowError("Re-run with more free memory!");
  1127.       CloseAll();
  1128.     }
  1129.     return;
  1130.   }
  1131.   pieceptr[N]->a = 0.5;
  1132.   pieceptr[N]->b = 0.0;
  1133.   pieceptr[N]->c = 0.0;
  1134.   pieceptr[N]->d = 0.5;
  1135.   pieceptr[N]->e = 0.25;              
  1136.   pieceptr[N]->f = 0.16938406;    /*   = 0.25*GZZHEIGHT/GZZWIDTH */
  1137.   pieceptr[N]->s1 = 0.5;
  1138.   pieceptr[N]->s2 = 0.5;
  1139.   pieceptr[N]->r1 = 0.0;
  1140.   pieceptr[N]->r2 = 0.0;
  1141.   pieceptr[N]->dens = 1.0;
  1142.   pieceptr[N]->det = 0.25;
  1143.   pieceptr[N]->boxo.x = 0.25 * GZZWIDTH;
  1144.   pieceptr[N]->boxo.y = 0.25 * GZZHEIGHT;
  1145.   pieceptr[N]->boxx.x = 0.75 * GZZWIDTH;
  1146.   pieceptr[N]->boxx.y = 0.25 * GZZHEIGHT;
  1147.   pieceptr[N]->boxy.x = 0.25 * GZZWIDTH;
  1148.   pieceptr[N]->boxy.y = 0.75 * GZZHEIGHT;
  1149.   pieceptr[N]->boxz.x = 0.75 * GZZWIDTH;
  1150.   pieceptr[N]->boxz.y = 0.75 * GZZHEIGHT;
  1151.  
  1152.   ComputeProbs();  /* Adjust all Piece probabilities */
  1153.   /* Transform Outline by this piece's transformation into its piecemap */
  1154.   TransformPiece(outlinebufptr, pieceptr[N]->piecemap, pieceptr[N]);
  1155.   selpiece = N;   /* make this Piece Selected */
  1156. }
  1157. /*===========================================================================*/
  1158.  
  1159. ComputeProbs()       /* Recompute all piece probabilities */
  1160. {
  1161.   double sum = 0;
  1162.  
  1163.   for (i = 0; i <= N; i++)
  1164.     sum = sum + pieceptr[i]->dens * pieceptr[i]->det;
  1165.  
  1166.   for (i = 0; i <= N; i++)
  1167.     pieceptr[i]->p = (pieceptr[i]->dens * pieceptr[i]->det)/sum;
  1168. }
  1169. /*===========================================================================*/
  1170.  
  1171. DrawBox()   /* Erase bitplane 3, and draw Vector Box of Selected Piece in it */
  1172. {
  1173.   SetWrMsk(r,0xFFF8);  /* Write-protect planes 0,1,2 */
  1174.   SetRast(r, 0L);      /* Erase plane 3 */
  1175.  
  1176.   SetAPen(r, 8L);    /*** Draw Vector Box */
  1177.   Move(r, pieceptr[selpiece]->boxo.x, pieceptr[selpiece]->boxo.y);
  1178.   Draw(r, pieceptr[selpiece]->boxx.x, pieceptr[selpiece]->boxx.y);
  1179.   Draw(r, pieceptr[selpiece]->boxz.x, pieceptr[selpiece]->boxz.y);
  1180.   Draw(r, pieceptr[selpiece]->boxy.x, pieceptr[selpiece]->boxy.y);
  1181.   Draw(r, pieceptr[selpiece]->boxo.x, pieceptr[selpiece]->boxo.y);
  1182.  
  1183.   SetDrMd(r, JAM2|INVERSVID); /*** Draw Corner "gadgets" */
  1184.   SetBPen(r, 0L);
  1185.   Move(r, pieceptr[selpiece]->boxo.x - 3L, pieceptr[selpiece]->boxo.y + 3L);
  1186.   Text(r, "O", 1L);
  1187.   Move(r, pieceptr[selpiece]->boxx.x - 3L, pieceptr[selpiece]->boxx.y + 3L);
  1188.   Text(r, "x", 1L);
  1189.   Move(r, pieceptr[selpiece]->boxz.x - 3L, pieceptr[selpiece]->boxz.y + 3L);
  1190.   Text(r, " ", 1L);
  1191.   Move(r, pieceptr[selpiece]->boxy.x - 3L, pieceptr[selpiece]->boxy.y + 3L);
  1192.   Text(r, "y", 1L);
  1193.  
  1194.   SetDrMd(r, JAM1);
  1195.   SetWrMsk(r,0xFFFF);
  1196. }
  1197. /*===========================================================================*/
  1198.  
  1199. ToggleGhostBox()        /* Draw or undraw current ghost box, as given in */
  1200. {                                /* ghbox? variables, in COMPLEMENT mode */
  1201.   SetDrMd(r, JAM1|COMPLEMENT);
  1202.   Move(r, ghboxo.x, ghboxo.y);
  1203.   Draw(r, ghboxx.x, ghboxx.y);
  1204.   Draw(r, ghboxz.x, ghboxz.y);
  1205.   Draw(r, ghboxy.x, ghboxy.y);
  1206.   Draw(r, ghboxo.x, ghboxo.y);
  1207.   SetDrMd(r, JAM1);
  1208.  
  1209. }
  1210. /*===========================================================================*/
  1211.  
  1212. ComputeNewBox()    /* Compute New Ghost Box from mouse coords, put in tmpbox */
  1213. {                  /* variables. */
  1214.   long dx, dy;   /* increments of mouse position from corner's previous pos */
  1215.   double s, a;   /* Scaling and Rotation components of change in vector Z */
  1216.   double cosa, sina;   /* cosine and sine of angle a */
  1217.   double Qx, Qy;
  1218.   double tmp;
  1219.  
  1220.   switch (curcor) { 
  1221.  
  1222.   case 'o':
  1223.     dx = mx - pieceptr[selpiece]->boxo.x;
  1224.     dy = my - pieceptr[selpiece]->boxo.y;
  1225.     tmpboxo.x = mx;
  1226.     tmpboxo.y = my;
  1227.     tmpboxx.x = pieceptr[selpiece]->boxx.x + dx;
  1228.     tmpboxx.y = pieceptr[selpiece]->boxx.y + dy;
  1229.     tmpboxy.x = pieceptr[selpiece]->boxy.x + dx;
  1230.     tmpboxy.y = pieceptr[selpiece]->boxy.y + dy;
  1231.     tmpboxz.x = pieceptr[selpiece]->boxz.x + dx;
  1232.     tmpboxz.y = pieceptr[selpiece]->boxz.y + dy;
  1233.     break;
  1234.  
  1235.   case 'x':
  1236.     dx = mx - pieceptr[selpiece]->boxx.x;
  1237.     dy = my - pieceptr[selpiece]->boxx.y;
  1238.     tmpboxo = pieceptr[selpiece]->boxo;   /* Structure Assignment */
  1239.     tmpboxx.x = mx;
  1240.     tmpboxx.y = my;
  1241.     tmpboxy = pieceptr[selpiece]->boxy;   /* Structure Assignment */
  1242.     tmpboxz.x = pieceptr[selpiece]->boxz.x + dx;
  1243.     tmpboxz.y = pieceptr[selpiece]->boxz.y + dy;
  1244.     break;
  1245.  
  1246.   case 'y':
  1247.     dx = mx - pieceptr[selpiece]->boxy.x;
  1248.     dy = my - pieceptr[selpiece]->boxy.y;
  1249.     tmpboxo = pieceptr[selpiece]->boxo;   /* Structure Assignment */
  1250.     tmpboxx = pieceptr[selpiece]->boxx;   /* Structure Assignment */
  1251.     tmpboxy.x = mx;
  1252.     tmpboxy.y = my;
  1253.     tmpboxz.x = pieceptr[selpiece]->boxz.x + dx;
  1254.     tmpboxz.y = pieceptr[selpiece]->boxz.y + dy;
  1255.     break;
  1256.  
  1257.   case 'z':
  1258.     s = sqrt((double)((mx-pieceptr[selpiece]->boxo.x)*
  1259.      (mx-pieceptr[selpiece]->boxo.x)+(my-pieceptr[selpiece]->boxo.y)*
  1260.      (my-pieceptr[selpiece]->boxo.y))/
  1261.      (double)((pieceptr[selpiece]->boxz.x-pieceptr[selpiece]->boxo.x)*
  1262.      (pieceptr[selpiece]->boxz.x-pieceptr[selpiece]->boxo.x)+
  1263.      (pieceptr[selpiece]->boxz.y-pieceptr[selpiece]->boxo.y)*
  1264.      (pieceptr[selpiece]->boxz.y-pieceptr[selpiece]->boxo.y)));
  1265.  
  1266.     a = myatan2((double)(my - pieceptr[selpiece]->boxo.y), (double)(mx - 
  1267.      pieceptr[selpiece]->boxo.x)) - myatan2((double)
  1268.      (pieceptr[selpiece]->boxz.y - pieceptr[selpiece]->boxo.y), 
  1269.      (double)(pieceptr[selpiece]->boxz.x - pieceptr[selpiece]->boxo.x));
  1270.  
  1271.     cosa = cos(a);
  1272.     sina = sin(a);
  1273.  
  1274.     Qx = pieceptr[selpiece]->boxo.x + s * (pieceptr[selpiece]->boxo.y * sina -
  1275.      pieceptr[selpiece]->boxo.x * cosa);
  1276.     Qy = pieceptr[selpiece]->boxo.y - s * (pieceptr[selpiece]->boxo.y * cosa +
  1277.      pieceptr[selpiece]->boxo.x * sina);
  1278.  
  1279.     tmpboxo = pieceptr[selpiece]->boxo;   /* Structure Assignment */
  1280.  
  1281.     /* Below, the conditional assignments assure rounding on the */
  1282.     /* double-to-int conversion rather than truncation */
  1283.     tmp = s * (pieceptr[selpiece]->boxx.x * cosa - 
  1284.      pieceptr[selpiece]->boxx.y * sina) + Qx;
  1285.     tmpboxx.x = (tmp - floor(tmp) > 0.5) ? tmp + 1. : tmp;
  1286.     tmp = s * (pieceptr[selpiece]->boxx.x * sina + 
  1287.      pieceptr[selpiece]->boxx.y * cosa) + Qy;
  1288.     tmpboxx.y = (tmp - floor(tmp) > 0.5) ? tmp + 1. : tmp;
  1289.     tmp = s * (pieceptr[selpiece]->boxy.x * cosa - 
  1290.      pieceptr[selpiece]->boxy.y * sina) + Qx;
  1291.     tmpboxy.x = (tmp - floor(tmp) > 0.5) ? tmp + 1. : tmp;
  1292.     tmp = s * (pieceptr[selpiece]->boxy.x * sina + 
  1293.      pieceptr[selpiece]->boxy.y * cosa) + Qy;
  1294.     tmpboxy.y = (tmp - floor(tmp) > 0.5) ? tmp + 1. : tmp;
  1295.     tmpboxz.x = tmpboxy.x + tmpboxx.x - tmpboxo.x;
  1296.     tmpboxz.y = tmpboxx.y + tmpboxy.y - tmpboxo.y;
  1297.     break;
  1298.   }         /* End switch curcor */
  1299. }
  1300. /*===========================================================================*/
  1301.  
  1302. DeleteSelPiece()  /* Delete the Selected Piece. If it was the only piece,  */
  1303. {                 /* replace it with a Default Piece. Rearrange Piece list */
  1304.   FreePiece(pieceptr[selpiece]);   /* free memory associated with the piece */
  1305.   for (i = selpiece; i < N; i++)   /* close gap in pointer array */
  1306.     pieceptr[i] = pieceptr[i+1];
  1307.   if (selpiece == N)
  1308.     selpiece--;
  1309.   N--;
  1310.  
  1311.   if (N == -1)     /* if deleted last piece, place a default piece */
  1312.     AddDefPiece();
  1313. }
  1314. /*==========================================================================*/
  1315.  
  1316. ClearIFS()  /* Clear IFS variables, memory, and Collage image */ 
  1317. {
  1318.   /* Clear all GZZ bitplanes except Outline plane */
  1319.   SetWrMsk(r,0xFFFD);  /* Write-protect plane 1, Outline */
  1320.   SetRast(r, 0L);
  1321.   SetWrMsk(r,0xFFFF);
  1322.  
  1323.   for(i = 0; i <= N; i++)
  1324.     FreePiece(pieceptr[i]);
  1325.   N = -1;
  1326. }
  1327. /*==========================================================================*/
  1328.  
  1329. HiliteGadget(gadgetid)        /* frame gadget of given ID# in Red */
  1330.         /* Implements in software Gadget Mutual Exclude */
  1331.         /* Because window is GZZ and gadgets are in its border, this routine */
  1332.         /* Draws the frame directly on the Screen,not in Window. It is quite */
  1333.         /* non-generic because gadget coordinates are coded in numerically */
  1334. int gadgetid;
  1335. {
  1336.   long i;
  1337.      /*** Define frames as border structures ***/
  1338.  
  1339.   static SHORT Frame_data[10] = { 0,0, 36,0, 36,15, 0,15, 0,0 };
  1340.                                               /* Gadget select frame data */
  1341.  
  1342.   static struct Border OnFrame_Bdr = {  /* Red (Selected) Gadget border */
  1343.      0,0,                 /* LeftEdge, TopEdge */
  1344.      4,0,JAM1,            /* FrontPen, BackPen, DrawMode */
  1345.      5,                   /* Count */
  1346.      Frame_data,          /* XY */
  1347.      NULL                 /* Next Border */
  1348.   };
  1349.  
  1350.   static struct Border OffFrame_Bdr = { /* Lt Green (deselected) Gadg border */
  1351.      0,0,                 /* LeftEdge, TopEdge */
  1352.      3,0,JAM1,            /* FrontPen, BackPen, DrawMode */
  1353.      5,                   /* Count */
  1354.      Frame_data,          /* XY */
  1355.      NULL                 /* Next Border */
  1356.   };
  1357.  
  1358.   /*** Unframe all gadgets, then frame selected one */ 
  1359.   for (i = 0; i <= 3; i++)
  1360.     DrawBorder(scrp, &OffFrame_Bdr, 280L, i*18L+12L);
  1361.   DrawBorder(scrp, &OnFrame_Bdr, 280L, gadgetid*18L+12L);
  1362. }
  1363. /*==========================================================================*/
  1364.  
  1365. DrawCollage()    /* Draw the current IFS as a collage image with */
  1366. {                /* vector Box of Selected Piece (wipe out old box)*/
  1367.   /*** Erase all bitplanes except Outline plane */
  1368.   SetWrMsk(r,0xFFFD);  /* Write-protect plane 1, Outline */
  1369.   SetRast(r, 0L);
  1370.  
  1371.   /* Blit Deselected pieces from piecemaps to plane 0 */
  1372.   SetWrMsk(r,0x0001);  /* Write protect all planes except plane 0 */
  1373.   SetAPen(r, 1L);
  1374.   for (i = 0; i <= N; i++)
  1375.     if (i != selpiece)    /* skip Selected piece */
  1376.       BltTemplate((char*)pieceptr[i]->piecemap,(long)Window->BorderLeft,
  1377.         (long)WIDTH/8, r, 0L, 0L, (long)GZZWIDTH, (long)GZZHEIGHT);
  1378.   /* Blit Selected Piece from piecemap to plane 2 */
  1379.   SetWrMsk(r,0x0004);  /* Write protect all planes except plane 2 */
  1380.   SetAPen(r, 4L);
  1381.   BltTemplate((char*)pieceptr[selpiece]->piecemap,(long)Window->BorderLeft,
  1382.    (long)WIDTH/8, r, 0L, 0L, (long)GZZWIDTH, (long)GZZHEIGHT);
  1383.   
  1384.   DrawBox();  /* Draw Vector Box of Selected Piece */
  1385.   /* Note that Rastport's WrMask is restored within DrawBox() */
  1386. }
  1387. /*==========================================================================*/
  1388.  
  1389. double myatan2(y,x) /* atan2() as defined in Aztec C but missing from mf.lib */
  1390. double x, y;        /* returns arctangent of y/x in range -pi to pi.         */
  1391. {                   /* If x=y=0, returns 0, sets errno=EDOM. */
  1392.                     /* Requires #include of errno.h and math.h */
  1393.  
  1394.   #define PI 3.141592654
  1395.   if (x == 0.0) {
  1396.     if (y == 0.0) {
  1397.       errno = EDOM;
  1398.       return(0.0);
  1399.     }
  1400.     else
  1401.       x = 1.0e-10;
  1402.   }
  1403.  
  1404.   if (y >= 0.0) {
  1405.     if (x >= 0.0)
  1406.       return(atan(y/x));        /* Quadrant I */
  1407.     else
  1408.       return(PI - atan(-y/x));  /* Quadrant II */
  1409.   }
  1410.   else {
  1411.     if (x >= 0.0)
  1412.       return(-atan(-y/x));      /* Quadrant IV */
  1413.     else
  1414.       return(atan(y/x) - PI);      /* Quadrant III */
  1415.   }
  1416. }
  1417. /*==========================================================================*/
  1418.  
  1419. ModifyMousePtr(Wind, n)
  1420.   /* Change to custom mouse pointer in Window if n=1, or restore default */
  1421.   /* arrow and free CHIP RAM if n=-1. Use in only one window at a time! */
  1422. struct Window *Wind;
  1423. int n;           
  1424. {
  1425.   static short *ChipPtr;
  1426.   static struct ViewPort *vprt;
  1427.   static long color17, color18, color19;
  1428.   long GetRGB4();
  1429.  
  1430.   /*** Define  Custom mouse pointer sprite data */
  1431.  
  1432.   #define ROWS 14    /* Number of Pixel rows in pointer */
  1433.  
  1434.   static USHORT Mouseptr[] = {
  1435.     0x0000, 0x0000,
  1436.                                   /*  ++++++++++++++++++  */
  1437.     0x00f0, 0x00f0,               /*  +        3333    +  */
  1438.     0x03f8, 0x03f8,               /*  +      3333333   +  */
  1439.     0x07fc, 0x079c,               /*  +     333311333  +  */
  1440.     0x0ffe, 0x0e0e,               /*  +    33311111333 +  */
  1441.     0x0ffe, 0x0c06,               /*  +    33111111133 +  */
  1442.     0xafff, 0x0c73,               /*  +1 1 331113331133+  */
  1443.     0xafff, 0x0cfb,               /*  +1 1 331133333133+  */
  1444.     0xafff, 0x0ccb,               /*  +1 1 331133113133+  */
  1445.     0xcfff, 0x0cdb,               /*  +11  331133133133+  */
  1446.     0xdfff, 0x18c3,               /*  +11 3311133111133+  */
  1447.     0xffff, 0x1ce7,               /*  +1113331133311333+  */
  1448.     0xfffe, 0x07fe,               /*  +111113333333333 +  */
  1449.     0x7ffe, 0x003c,               /*  + 11111111133331 +  */
  1450.     0x1fff, 0x0000,               /*  +   1111111111111+  */
  1451.                                   /*  ++++++++++++++++++  */
  1452.     0x0000, 0x0000
  1453.   };
  1454.  
  1455.   if (n == 1 && ChipPtr == NULL) { 
  1456.  
  1457.     /*** Get colors of default pointer in Window's screen */
  1458.     vprt = &(Wind->WScreen->ViewPort); /* ptr to viewport of screen */
  1459.     color17 = GetRGB4(vprt->ColorMap, 17L);
  1460.     color18 = GetRGB4(vprt->ColorMap, 18L);
  1461.     color19 = GetRGB4(vprt->ColorMap, 19L);
  1462.  
  1463.     /*** Copy sprite data into chip RAM to be accessible to graphic chips */
  1464.     ChipPtr =(short*)AllocMem((long)((ROWS+2)*4),MEMF_CHIP); /* Alloc block */
  1465.     CopyMem((char*)Mouseptr,(char*)ChipPtr,(long)((ROWS+2)*4)); /* Copy data*/
  1466.     /*** Attach custom pointer to window */
  1467.     SetPointer(Wind, ChipPtr, (long)ROWS, 16L, -1L, -1L);
  1468.  
  1469.     /*** Change custom pointer colors */
  1470.     SetRGB4(vprt, 17L, 15L, 12L, 10L);
  1471.     SetRGB4(vprt, 18L, 13L, 2L, 2L); 
  1472.     SetRGB4(vprt, 19L, 15L, 0L, 0L); 
  1473.   }
  1474.   else if (n == -1 && ChipPtr != NULL) {
  1475.     ClearPointer(Wind);     /* Reset default pointer and its original colors */
  1476.     SetRGB4(vprt, 17L,  color17>>8, (color17>>4L)&15, color17&15);
  1477.     SetRGB4(vprt, 18L,  color18>>8, (color18>>4L)&15, color18&15);
  1478.     SetRGB4(vprt, 19L,  color19>>8, (color19>>4L)&15, color19&15);
  1479.     FreeMem(ChipPtr, (long)((ROWS+2)*4)); /* release memory of pointer data */
  1480.     ChipPtr = NULL;
  1481.   }
  1482.   else 
  1483.    DisplayBeep(NULL);  /* Illegal call (called twice in a row with same n */
  1484. }
  1485. /*===========================================================================*/
  1486.  
  1487. UpdateNumStrings()   /* Update values of Coeff window string gadgets from */
  1488. {       /* selected piece structure. Redraw gadgets if the window is open */
  1489.   double degr1, degr2;
  1490.  
  1491.   degr1 = pieceptr[selpiece]->r1 / 0.017453293; /* convert radians to degrees*/
  1492.   degr2 = pieceptr[selpiece]->r2 / 0.017453293;
  1493.  
  1494.   sprintf((char*)NumNumT2coeffGadgSIBuff, "%5.2lf", pieceptr[selpiece]->f);
  1495.   sprintf((char*)NumNumT1coeffGadgSIBuff, "%5.2lf", pieceptr[selpiece]->e);
  1496.   sprintf((char*)NumNumR2coeffGadgSIBuff, "%5.lf", degr2);
  1497.   sprintf((char*)NumNumR1coeffGadgSIBuff, "%5.lf", degr1);
  1498.   sprintf((char*)NumNumS2coeffGadgSIBuff, "%5.2lf", pieceptr[selpiece]->s2);
  1499.   sprintf((char*)NumNumS1coeffGadgSIBuff, "%5.2lf", pieceptr[selpiece]->s1);
  1500.   sprintf((char*)NumNumPcoeffGadgSIBuff, "%5.3lf", pieceptr[selpiece]->p);
  1501.   sprintf((char*)NumNumDenscoeffGadgSIBuff,"%4.1lf", pieceptr[selpiece]->dens);
  1502.   sprintf((char*)NumNumFcoeffGadgSIBuff, "%5.2lf", pieceptr[selpiece]->f);
  1503.   sprintf((char*)NumNumEcoeffGadgSIBuff, "%5.2lf", pieceptr[selpiece]->e);
  1504.   sprintf((char*)NumNumDcoeffGadgSIBuff, "%5.2lf", pieceptr[selpiece]->d);
  1505.   sprintf((char*)NumNumCcoeffGadgSIBuff, "%5.2lf", pieceptr[selpiece]->c);
  1506.   sprintf((char*)NumNumBcoeffGadgSIBuff, "%5.2lf", pieceptr[selpiece]->b);
  1507.   sprintf((char*)NumNumAcoeffGadgSIBuff, "%5.2lf", pieceptr[selpiece]->a);
  1508.   if (exists_numwindow)
  1509.     RefreshGadgets(&NumGadgetList3, NumWindow, NULL);
  1510. }
  1511. /*===========================================================================*/
  1512.  
  1513. RecomputeCoeffs(gadgetid)         /* Re-Calculate 13 coefficients based on */
  1514. int gadgetid;      /* change in value of the one in the string gadget with */
  1515. {                  /* the given gadgetid; put new values in string gadgets */
  1516.                    /* Does range checking on entered coefficients; If user */
  1517.                    /* entered an illegal value, will restore previous      */
  1518.                    /* value and inform user before returning.              */
  1519.   double a, b, c, d, e, f, s1, s2, r1, r2, t1, t2, dens, p;
  1520.   double sum, p0, det, olddet, olddens;
  1521.  
  1522.   /* Put current coefficient values into temporary variables */
  1523.   sscanf((char*)NumNumT2coeffGadgSIBuff, "%lf", &t2);
  1524.   sscanf((char*)NumNumT1coeffGadgSIBuff, "%lf", &t1);
  1525.   sscanf((char*)NumNumR2coeffGadgSIBuff, "%lf", &r2);
  1526.   sscanf((char*)NumNumR1coeffGadgSIBuff, "%lf", &r1);
  1527.   sscanf((char*)NumNumS2coeffGadgSIBuff, "%lf", &s2);
  1528.   sscanf((char*)NumNumS1coeffGadgSIBuff, "%lf", &s1);
  1529.   sscanf((char*)NumNumPcoeffGadgSIBuff, "%lf", &p);
  1530.   sscanf((char*)NumNumDenscoeffGadgSIBuff, "%lf", &dens);
  1531.   sscanf((char*)NumNumFcoeffGadgSIBuff, "%lf", &f);
  1532.   sscanf((char*)NumNumEcoeffGadgSIBuff, "%lf", &e);
  1533.   sscanf((char*)NumNumDcoeffGadgSIBuff, "%lf", &d);
  1534.   sscanf((char*)NumNumCcoeffGadgSIBuff, "%lf", &c);
  1535.   sscanf((char*)NumNumBcoeffGadgSIBuff, "%lf", &b);
  1536.   sscanf((char*)NumNumAcoeffGadgSIBuff, "%lf", &a);
  1537.  
  1538.   while (r1 > 180. || r1 < -180.) /* Get angles to range -180 => +180 */
  1539.     r1 = (r1 > 0.) ? r1 - 360. : r1 + 360.;
  1540.   while (r2 > 180. || r2 < -180.)
  1541.     r2 = (r2 > 0.) ? r2 - 360. : r2 + 360.;
  1542.  
  1543.   r1 = r1*0.017453293;            /* convert degrees to radians*/
  1544.   r2 = r2*0.017453293;
  1545.  
  1546.   /*** Check that all coefficients are in legal ranges */
  1547.   if (a < -1. || a > 1. || b < -1. || b > 1. || c < -1. || c > 1. ||
  1548.       d < -1. || d > 1. || e < -0.25 || e > 1. || f < -0.25 || f > 1. ||
  1549.       s1 < -1. || s1 > 1. || s2 < -1. || s2 > 1. || dens <= 0. ||
  1550.       t1 < -0.25 || t1 > 1. || t2 < -0.25 || t2 > 1. || p <= 0. || p > 1.) {
  1551.     ShowError("Coefficient out of Range!");
  1552.     a = pieceptr[selpiece]->a;    /*** Undo the error */
  1553.     b = pieceptr[selpiece]->b;
  1554.     c = pieceptr[selpiece]->c;
  1555.     d = pieceptr[selpiece]->d;
  1556.     e = pieceptr[selpiece]->e;
  1557.     f = pieceptr[selpiece]->f;
  1558.     p = pieceptr[selpiece]->p;
  1559.     dens = pieceptr[selpiece]->dens;
  1560.     s1 = pieceptr[selpiece]->s1;
  1561.     s2 = pieceptr[selpiece]->s2;
  1562.     r1 = pieceptr[selpiece]->r1;
  1563.     r2 = pieceptr[selpiece]->r2;
  1564.     t1 = pieceptr[selpiece]->e;
  1565.     t2 = pieceptr[selpiece]->f;
  1566.   }
  1567.  
  1568.   det = fabs(a * d - b * c);
  1569.   if (det == 0.0)
  1570.     det = 0.01;
  1571.   sum = -(pieceptr[selpiece]->dens * pieceptr[selpiece]->det) + dens * det;
  1572.   for (i = 0; i <= N; i++)
  1573.     sum = sum + pieceptr[i]->dens * pieceptr[i]->det;
  1574.  
  1575.   if (gadgetid <= 26) {   /* id's 21 thru 26, matrix coeffs a - f */
  1576.     s1 = sqrt(a*a + c*c);
  1577.     s2 = sqrt(b*b + d*d);
  1578.     r1 = myatan2(c, a);
  1579.     r2 = myatan2(-b, d);
  1580.     t1 = e;
  1581.     t2 = f;
  1582.     p = (dens * det)/sum;
  1583.   }
  1584.  
  1585.   if (gadgetid == 27) {   /* density coefficient */
  1586.     p = (dens * det)/sum;
  1587.   }
  1588.  
  1589.   if (gadgetid == 28)  {   /* probability coefficient */
  1590.     olddens = dens;
  1591.     p0 = det / (sum - olddens*det + det); /* What p SHOULD be with dens == 1 */
  1592.     dens = p / p0;
  1593.     p = (dens * det)/(sum - olddens*det + dens*det);
  1594.   }
  1595.  
  1596.   if (gadgetid >= 29) {   /* id's 29 thru 34, geometrical coeffs s1 thru t2 */
  1597.     olddet = fabs(a * d - b * c);
  1598.     if (olddet == 0.0)
  1599.       olddet = 0.01;
  1600.     a = s1 * cos(r1);
  1601.     b = -s2 * sin(r2);
  1602.     c = s1 * sin(r1);
  1603.     d = s2 * cos(r2);
  1604.     e = t1;
  1605.     f = t2;
  1606.     det = fabs(a * d - b * c);  /*** recompute det and probability */
  1607.     if (det == 0.0)
  1608.       det = 0.01;
  1609.     sum = sum - olddet*dens + det*dens;
  1610.     p = (dens * det)/sum;
  1611.   }
  1612.  
  1613.   r1 = r1 / 0.017453293; /* convert radians to degrees */
  1614.   r2 = r2 / 0.017453293;
  1615.  
  1616.   /* Put resultant coefficient values into their string gadgets */
  1617.   sprintf((char*)NumNumT2coeffGadgSIBuff, "%5.2lf", f);
  1618.   sprintf((char*)NumNumT1coeffGadgSIBuff, "%5.2lf", e);
  1619.   sprintf((char*)NumNumR2coeffGadgSIBuff, "%5.lf", r2);
  1620.   sprintf((char*)NumNumR1coeffGadgSIBuff, "%5.lf", r1);
  1621.   sprintf((char*)NumNumS2coeffGadgSIBuff, "%5.2lf", s2);
  1622.   sprintf((char*)NumNumS1coeffGadgSIBuff, "%5.2lf", s1);
  1623.   sprintf((char*)NumNumPcoeffGadgSIBuff, "%5.3lf", p);
  1624.   sprintf((char*)NumNumDenscoeffGadgSIBuff, "%4.1lf", dens);
  1625.   sprintf((char*)NumNumFcoeffGadgSIBuff, "%5.2lf", f);
  1626.   sprintf((char*)NumNumEcoeffGadgSIBuff, "%5.2lf", e);
  1627.   sprintf((char*)NumNumDcoeffGadgSIBuff, "%5.2lf", d);
  1628.   sprintf((char*)NumNumCcoeffGadgSIBuff, "%5.2lf", c);
  1629.   sprintf((char*)NumNumBcoeffGadgSIBuff, "%5.2lf", b);
  1630.   sprintf((char*)NumNumAcoeffGadgSIBuff, "%5.2lf", a);
  1631.  
  1632.   return;
  1633. }
  1634. /*==========================================================================*/
  1635.  
  1636. ShowError(text)    /* Show error message in a Window, return on user */
  1637.                    /* clicking in the OK gadget. Text string must not */
  1638.                    /* exceed Window's width minus two characters. */
  1639.                    /* Window is used and not a requester so it is in front */
  1640.                    /* of coeffs window & GZZ Border of main Window */
  1641. char *text;  /* The message to be displayed */
  1642. {
  1643.   struct Message * GetMsg();
  1644.   void ReplyMsg();
  1645.   struct IntuiMessage *message;
  1646.   int gadgetid;
  1647.   struct Window *ErrWindow, *OpenWindow();
  1648.  
  1649.   #define TEXTCOLOR 3      /* Text color for message and "OK" */
  1650.   #define BGCOLOR   14     /* Color for Window and Gadget background */
  1651.   #define GADGBDRCOLOR 3   /* Color for border of "OK" Gadget */
  1652.   #define BDRCOLOR 3       /* Color for border of Error-window */
  1653.  
  1654.   /*** Initialize Error-window structures */
  1655.  
  1656.   static  struct IntuiText OKGadgetMsg = {
  1657.     TEXTCOLOR, BGCOLOR,  /* FrontPen, BackPen */
  1658.     JAM1,                /* DrawMode */
  1659.     4,3,                 /* LeftEdge, TopEdge */
  1660.     NULL,                /* ITextFont */
  1661.     (UBYTE*)"OK",        /* IText */
  1662.     NULL                 /* NextText */
  1663.   };
  1664.  
  1665.   static SHORT OKGadgetCoord[18] = { 0,0, 23,0, 23,12, 0,12, 0,0,
  1666.                                      24,0, 24,12, -1,12, -1,0 };
  1667.   /* NOTE: Second line above gives 2-pixel-wide border for hires screen */
  1668.  
  1669.   static struct Border OKGadgetBdr = {
  1670.     0,0,                 /* LeftEdge, TopEdge */
  1671.     GADGBDRCOLOR, BGCOLOR, JAM1,   /* FrontPen, BackPen, DrawMode */
  1672.     9,                   /* Count */
  1673.     &OKGadgetCoord[0],   /* XY */
  1674.     NULL                 /* NextBorder */
  1675.   };
  1676.  
  1677.   static struct Gadget OKGadget = {
  1678.     NULL,                /*  NextGadget */
  1679.     -40,35,24,13,       /* LeftEdge, TopEdge, Width, Height */
  1680.     GADGHCOMP | GRELRIGHT,  /* Flags */
  1681.     ENDGADGET |
  1682.     RELVERIFY,           /* Activation */
  1683.     BOOLGADGET,          /* GadgetType */
  1684.     (APTR)&OKGadgetBdr,  /* GadgetRender */
  1685.     NULL,                /* SelectRender */
  1686.     &OKGadgetMsg,        /* GadgetText */
  1687.     0,                   /* MutualExclude */
  1688.     NULL,                /* SpecialInfo */
  1689.     99,                  /* GadgetID */
  1690.     NULL                 /* UserData */
  1691.   };
  1692.   
  1693.   static SHORT BdrCoords[10] = { 2,2, 0,2, 0,57, 2,57, 2,2 };
  1694.                                               /* 0's to be replaced later */
  1695.   static struct Border Bdr = {
  1696.     0, 0,           /* LeftEdge, TopEdge */
  1697.     BDRCOLOR, BGCOLOR, JAM1,   /* FrontPen, BackPen, DrawMode */
  1698.     5,              /* Count */
  1699.     &BdrCoords[0],  /* XY */
  1700.     NULL            /* NextBorder */
  1701.   };
  1702.  
  1703.   static struct IntuiText ErrText = {
  1704.     TEXTCOLOR, BGCOLOR, JAM1,   /* FrontPen, BackPen, DrawMode */
  1705.     8, 18,             /* LeftEdge, TopEdge */
  1706.     NULL,              /* ITextFont */
  1707.     NULL,              /* IText -- Will be filled later */
  1708.     NULL,              /* NextText */
  1709.   };
  1710.  
  1711.   static struct Image ErrWinBgnd = {    /* Just a filled rectangle */
  1712.     0, 0,              /* LeftEdge, TopEdge */
  1713.     0, 60, 0,          /* Width,Height, Depth */
  1714.     NULL,              /* ImageData */
  1715.     0x0, 0xE,          /* PlanePick, PlaneOnOff */
  1716.     NULL               /* NextImage */
  1717.   };
  1718.  
  1719.   static struct NewWindow ErrNewWindow = {
  1720.     0,60,   /* window XY origin relative to TopLeft of screen */
  1721.     0,60,    /* window width and height */
  1722.     TEXTCOLOR,BDRCOLOR,  /* detail and block pens */
  1723.     GADGETUP,  /* IDCMP flags */
  1724.     ACTIVATE|SIMPLE_REFRESH|BORDERLESS,  /* other window flags */
  1725.     &OKGadget,   /* first gadget in gadget list */
  1726.     NULL,   /* custom CHECKMARK imagery */
  1727.     NULL,   /* window title */
  1728.     NULL,   /* custom screen pointer */
  1729.     NULL,   /* custom bitmap */
  1730.     5,5,    /* minimum width and height */
  1731.     -1,-1,  /* maximum width and height */
  1732.     CUSTOMSCREEN  /* destination screen type */
  1733.   };
  1734.  
  1735.   /*** Compute and fill in text and window-dependent stuff */
  1736.  
  1737.   ErrNewWindow.Screen = Screen;
  1738.   ErrNewWindow.Width = strlen(text) * 8 + 16;
  1739.   if (ErrNewWindow.Width < 44)
  1740.     ErrNewWindow.Width = 44;
  1741.   ErrWinBgnd.Width = ErrNewWindow.Width;
  1742.  
  1743.   ErrNewWindow.LeftEdge = (320 - ErrNewWindow.Width)/2;
  1744.   if (ErrNewWindow.LeftEdge < 0)
  1745.     ErrNewWindow.LeftEdge = 0;
  1746.  
  1747.   BdrCoords[2] = BdrCoords[4] = ErrNewWindow.Width - 3;
  1748.  
  1749.   ErrText.IText = (UBYTE*)text;
  1750.  
  1751.   if (Window->WScreen->Width = 320) /* If Lo-res -- remove vert. double line */
  1752.     OKGadgetBdr.Count = 5;
  1753.   else
  1754.     OKGadgetBdr.Count = 9;
  1755.  
  1756.   /*** Display the Error-Window */
  1757.  
  1758.  
  1759.   if ((ErrWindow = OpenWindow(&ErrNewWindow)) == NULL) {
  1760.     printf("\nCouldn't open Error Message window!!!\n");
  1761.     CloseAll();
  1762.   }
  1763.   DrawImage(ErrWindow->RPort, &ErrWinBgnd, 0L, 0L);
  1764.   PrintIText(ErrWindow->RPort, &ErrText, 0L, 0L);
  1765.   DrawBorder(ErrWindow->RPort, &Bdr, 0L, 0L);
  1766.   RefreshGadgets(&OKGadget, ErrWindow, NULL);
  1767.                      /* Because DrawImage() obscured the OK Gadget image */
  1768.  
  1769.   /*** Wait until user clicks the Error-window's "OK" Gadget */
  1770.   gadgetid = 9999;
  1771.   while (gadgetid != 99) {
  1772.     if (message = (struct IntuiMessage *)GetMsg(ErrWindow->UserPort)) { 
  1773.       gadgetid = ((struct Gadget *)(message->IAddress))->GadgetID;
  1774.       ReplyMsg(message);
  1775.     }
  1776.   }
  1777.   CloseWindow(ErrWindow);
  1778. }
  1779. /*===========================================================================*/
  1780.  
  1781. OpenImageScreen(width, height, depth)  /* Open a Custom screen & window for */
  1782.                                        /* the Image; Set exists_image flag */
  1783. int width, height, depth;
  1784. { 
  1785.   struct NewScreen ns;
  1786.   struct Screen *OpenScreen();
  1787.   struct NewWindow nw;
  1788.   struct Window *OpenWindow();
  1789.   long numcols;  /* # of colors in screen */
  1790.   UWORD *colortableptr[5];   /* Array of Pointers to screen colortables */
  1791.                              /* Note: element 0 is not used! */
  1792.  
  1793.   static UWORD colortable1[] =     /*** Colors for 1-bitplane screen */
  1794.     {0x000, 0x068, 0x0AF, 0x5CF};
  1795.   static UWORD colortable2[] =     /*** Colors for 2-bitplane screen */
  1796.     {0x000, 0x057, 0x07B, 0xAF};
  1797.   static UWORD colortable3[] =     /*** Colors for 3-bitplane screen */
  1798.     {0x000, 0x034, 0x046, 0x068, 0x06A, 0x08C, 0x09E, 0x0AF};
  1799.   static UWORD colortable4[] =     /*** Colors for 4-bitplane screen */
  1800.     {0x000, 0x011, 0x012, 0x023, 0x034, 0x045, 0x046, 0x057,
  1801.      0x068, 0x069, 0x06A, 0x07B, 0x08C, 0x08D, 0x09E, 0x0AF};
  1802.  
  1803.   colortableptr[1] = colortable1; 
  1804.   colortableptr[2] = colortable2; 
  1805.   colortableptr[3] = colortable3; 
  1806.   colortableptr[4] = colortable4;
  1807.  
  1808.   ns.LeftEdge = 0;      /*** Initialize NewScreen structure */
  1809.   ns.TopEdge = 0;
  1810.   ns.Width = width;
  1811.   ns.Height = height;
  1812.   ns.Depth = (depth == 1) ? 2 : depth;
  1813.   ns.DetailPen = 3;  /* Colour of text in screen title bar */
  1814.   ns.BlockPen = 1;   /* Colour of screen Title Bar */
  1815.   ns.ViewModes = ((width == 640) ? HIRES:0) | ((height == 400) ? INTERLACE:0);
  1816.   ns.Type = CUSTOMSCREEN;
  1817.   ns.Font = &TOPAZ80;
  1818.   ns.DefaultTitle = (UBYTE*)" Click in screen to stop rendering";
  1819.   ns.Gadgets = NULL;
  1820.   ns.CustomBitMap = NULL;
  1821.  
  1822.   switch (depth) {    /* Customize Image Title and Border colors to depth */
  1823.   case (1):
  1824.     ns.DetailPen = 3;
  1825.     ns.BlockPen = 1;
  1826.     break;
  1827.   case (2):
  1828.     ns.DetailPen = 3;
  1829.     ns.BlockPen = 1;
  1830.     break;
  1831.   case (3):
  1832.     ns.DetailPen = 7;
  1833.     ns.BlockPen = 3;
  1834.     break;
  1835.   case (4):
  1836.     ns.DetailPen = 15;
  1837.     ns.BlockPen = 7;
  1838.     break;
  1839.   }
  1840.  
  1841.   nw.LeftEdge = 0;         /*** Initialize NewWindow structure */
  1842.   nw.TopEdge = 0;
  1843.   nw.Width = width;
  1844.   nw.Height = height;
  1845.   nw.DetailPen = ns.DetailPen; /* Title text color */
  1846.   nw.BlockPen  = ns.BlockPen;  /* Title bar background */
  1847.   nw.IDCMPFlags = MOUSEBUTTONS;
  1848.   nw.Flags = ACTIVATE|GIMMEZEROZERO|SIMPLE_REFRESH|BACKDROP;
  1849.   nw.FirstGadget = NULL;
  1850.   nw.CheckMark = NULL;
  1851.   nw.Title = (UBYTE*)" ";   /* Never seen - stays behind screen title bar */
  1852.   nw.Screen = NULL; /* Will set it to ImageScreen after the screen is opened */
  1853.   nw.BitMap = NULL;
  1854.   nw.MinWidth = 0;
  1855.   nw.MinHeight = 0;
  1856.   nw.MaxWidth = 0;
  1857.   nw.MaxHeight = 0;
  1858.   nw.Type = CUSTOMSCREEN;
  1859.  
  1860.   /*** Open the screen */
  1861.   if ((ImageScreen = (struct Screen *) OpenScreen(&ns)) == NULL) {
  1862.     ShowError("Couldn't open Image screen!");
  1863.     return;
  1864.   }
  1865.  
  1866.   /* Link Custom colours defined above to screen's ViewPort */  
  1867.   numcols = 1 << ns.Depth;
  1868.   LoadRGB4(&(ImageScreen->ViewPort), colortableptr[depth], numcols);
  1869.  
  1870.   /*** Open the Window */
  1871.   nw.Screen = ImageScreen;
  1872.   if ((ImageWindow = (struct Window *) OpenWindow(&nw)) == NULL) {
  1873.     CloseScreen(ImageScreen);
  1874.     ShowError("Couldn't open Image window!");
  1875.     return;
  1876.   }
  1877.   SetWindowTitles(ImageWindow,-1L,
  1878.                               (char *)" Click in screen to stop rendering");
  1879.   exists_image = 1;
  1880. }
  1881. /*===========================================================================*/
  1882.  
  1883. CloseImageScreen()   /* Close image screen & Window, reset exists_image flag */
  1884. {
  1885.   struct Message * GetMsg();
  1886.   void ReplyMsg();
  1887.   struct IntuiMessage *message;
  1888.  
  1889.   /* Empty ImageWindow IDCMP queue if any */
  1890.   while (message = (struct IntuiMessage *)GetMsg(ImageWindow->UserPort))
  1891.       ReplyMsg(message);
  1892.  
  1893.   CloseWindow(ImageWindow);
  1894.   CloseScreen(ImageScreen);
  1895.   exists_image = 0;
  1896. }
  1897. /*===========================================================================*/
  1898.  
  1899. DoDemo()        /* Demonstrate IFS process, then NEW and return */
  1900. {
  1901.   if (SetMode(OUTLINE) == 1) {
  1902.     SetRast(r, 0L);
  1903.     exists_outline = 0;
  1904.   }
  1905.   else   /* User clicked CANCEL in IFS WILL BE LOST requester - Abort demo */
  1906.     return;
  1907.   ModifyIDCMP(Window, NULL);   /* Disable Editor Window IDCMP during Demo */
  1908.   ClearMenuStrip(Window); /* remove main window menus during demo */
  1909.   AboutText(DEMOTEXT);    /* Show explanation of demo in text screen */
  1910.   ModifyMousePtr(Window, 1);   /* Bring up 'ZZ' pointer */
  1911.  
  1912.   /* Draw outline of Sierpinski Triangle */
  1913.   SetDrMd(r, JAM1);
  1914.   for (i = 0; i < 100000; i++) ; /* Delay */
  1915.   Move(r, 138L, 24L);
  1916.   Draw(r, 24L, 172L);
  1917.   for (i = 0; i < 100000; i++) ; /* Delay */
  1918.   Draw(r, 238L, 131L);
  1919.   for (i = 0; i < 100000; i++) ; /* Delay */
  1920.   Draw(r, 138L, 24L);
  1921.   for (i = 0; i < 100000; i++) ; /* Delay */
  1922.   Move(r, 82L, 98L);
  1923.   Draw(r, 188L, 77L);
  1924.   for (i = 0; i < 100000; i++) ; /* Delay */
  1925.   Draw(r, 130L, 152L);
  1926.   for (i = 0; i < 100000; i++) ; /* Delay */
  1927.   Draw(r, 82L, 98L);
  1928.   exists_outline = 1;
  1929.   for (i = 0; i < 150000; i++)  /* Delay before entering Collage Editor */
  1930.     ;
  1931.  
  1932.   /*** Place 3 Pieces to form Collage */
  1933.  
  1934.   SetMode(COLLAGE);
  1935.   for (i = 0; i < 100000; i++) ; /* Delay */
  1936.   ModifyMousePtr(Window, -1);   /* Remove 'ZZ' pointer */
  1937.   AddDefPiece();
  1938.   DrawCollage();
  1939.   pieceptr[0]->e = 0.25;
  1940.   pieceptr[0]->f = 0.045;
  1941.   pieceptr[0]->dens = 1.0;
  1942.   ComputeBoxCorners(pieceptr[0]);
  1943.   ComputeProbs();
  1944.   for (i = 0; i < 100000; i++) ; /* Delay */
  1945.   TransformPiece(outlinebufptr, pieceptr[0]->piecemap, pieceptr[0]);
  1946.   DrawCollage();
  1947.  
  1948.   for (i = 0; i < 100000; i++) ; /* Delay */
  1949.   AddDefPiece();
  1950.   DrawCollage();
  1951.   pieceptr[1]->e = 0.045;
  1952.   pieceptr[1]->f = 0.315;
  1953.   pieceptr[1]->dens = 0.4;
  1954.   ComputeBoxCorners(pieceptr[1]);
  1955.   ComputeProbs();
  1956.   for (i = 0; i < 100000; i++) ; /* Delay */
  1957.   TransformPiece(outlinebufptr, pieceptr[1]->piecemap, pieceptr[1]);
  1958.   DrawCollage();
  1959.  
  1960.   for (i = 0; i < 100000; i++) ; /* Delay */
  1961.   AddDefPiece();
  1962.   DrawCollage();
  1963.   pieceptr[2]->e = 0.43;
  1964.   pieceptr[2]->f = 0.24;   
  1965.   pieceptr[2]->dens = 0.7;
  1966.   ComputeBoxCorners(pieceptr[2]);
  1967.   ComputeProbs();
  1968.   for (i = 0; i < 100000; i++) ; /* Delay */
  1969.   TransformPiece(outlinebufptr, pieceptr[2]->piecemap, pieceptr[2]);
  1970.   DrawCollage();
  1971.  
  1972.   for (i = 0; i < 300000; i++)  /* Delay before rendering */
  1973.     ;
  1974.   RenderImage(0);               /* Render, until user clicks in image screen */
  1975.  
  1976.   /*** After rendering ended, do a NEW (without IFS WILL BE LOST requester) */
  1977.   ClearIFS();
  1978.   RemoveGList(Window, &CollageGadgetList2, 6L);
  1979.   AddGList(Window, &GadgetList1, 0L, 6L, NULL); /* change gadgets */
  1980.   SetDrMd(scrp, JAM1);
  1981.   SetAPen(scrp, 0L);
  1982.   RectFill(scrp, 280L, 12L, 316L, 117L); /* Blot out old gadget images */
  1983.   RefreshGadgets(&GadgetList1, Window, NULL);
  1984.   OffMenu(Window, NOITEM<<5 | 2);     /* disable render menu and its items */
  1985.   SetWindowTitles(Window, -1L, "           Outline Editor");
  1986.   drawmode = FREEHAND;
  1987.   HiliteGadget(0);
  1988.   SetAPen(r, 2L);
  1989.   SetRast(r, 0L);
  1990.   exists_outline = 0;
  1991.   CloseImageScreen();
  1992.   ModifyIDCMP(Window, MOUSEBUTTONS|GADGETUP|MENUPICK);  /* Restore IDCMP */
  1993.   SetMenuStrip(Window, &MenuList1);  /* Restore menu strip */
  1994. }
  1995. /*===========================================================================*/
  1996.  
  1997. ComputeBoxCorners(pcptr)     /* Compute Vector Box corners from Piece coeffs */
  1998. struct piece *pcptr;
  1999. {
  2000.   pcptr->boxo.x = pcptr->e * GZZWIDTH;
  2001.   pcptr->boxo.y = pcptr->f * GZZWIDTH; /* sic! */
  2002.   pcptr->boxx.x = (pcptr->a + pcptr->e) * GZZWIDTH;
  2003.   pcptr->boxx.y = (pcptr->c + pcptr->f) * GZZWIDTH;
  2004.   pcptr->boxy.x = (pcptr->b*GZZHEIGHT/GZZWIDTH + pcptr->e) * GZZWIDTH;
  2005.   pcptr->boxy.y = (pcptr->d*GZZHEIGHT/GZZWIDTH + pcptr->f) * GZZWIDTH;
  2006.   pcptr->boxz.x =  pcptr->boxy.x + pcptr->boxx.x - pcptr->boxo.x;
  2007.   pcptr->boxz.y = pcptr->boxy.y + pcptr->boxx.y - pcptr->boxo.y;
  2008. }
  2009. /*===========================================================================*/
  2010.  
  2011. LoadILBM(fnam, dest)        /* Load an Image from IFF file; If dest = 1,    */
  2012. char *fnam;                 /* put image and colormap in Image Screen;      */
  2013. int dest;                   /* if dest = 0, put plane 0 of image in Outline */
  2014. {
  2015.   struct BitMap picbitmap = {0};    /* Empty BitMap structure to "Fill" */
  2016.   ILBMFrame iFrame;         /* ILBM Frame to be used by Reader Routines */
  2017.   LONG file;  /* File handle [we use AmigaDOS Open(), not Manx open()] */
  2018.   LONG iffp;
  2019.   char *blitbuffer; /* Needed for the Blit operation only */
  2020.   struct BitMap tmpbitmap;  /* used for 2-step blit to Outline */
  2021.  
  2022.   #define MIN(a,b) ((a)<(b)?(a):(b))
  2023.  
  2024.   /* Open the File to read */
  2025.   if ((file = Open(fnam, MODE_OLDFILE)) == NULL) {
  2026.     ShowError("Can't open file!");
  2027.     return;
  2028.   }
  2029.   ModifyMousePtr(Window, 1);   /* Bring up 'ZZ' pointer */
  2030.  
  2031.   /* Use EA IFF routine ReadPicture() to Read image from ILBM file into */
  2032.   /*  memory, modify picbitmap accordingly */
  2033.  
  2034.   iffp = ReadPicture(file,&picbitmap,&iFrame,ChipAlloc);
  2035.  
  2036.   Close(file);
  2037.  
  2038.   if (iffp != IFF_DONE) {  /* React to error message from EA routine, if any */
  2039.     ShowError(IFFPMessages[-iffp]);
  2040.     if (picbitmap.Planes[0]) /* free planes allocated by ReadPicture, if any */
  2041.       RemFree(picbitmap.Planes[0]);
  2042.     ModifyMousePtr(Window, -1);   /* Remove 'ZZ' pointer */
  2043.     return;
  2044.   }
  2045.  
  2046.   /*** Now image is in memory; copy it to the proper destination bitmap */
  2047.  
  2048.   switch (dest) {
  2049.  
  2050.   case 0:  /***  Copy plane 0 of loaded image to Outline (plane 1 in Window) */
  2051.  
  2052.     SetRast(r, 0L);   /* Erase old outline, set drawmode to FREEHAND */
  2053.     if(drawmode == ERASE || drawmode == FILL) {
  2054.       drawmode = FREEHAND;
  2055.       SetAPen(r,2L);
  2056.       HiliteGadget(0);
  2057.     }
  2058.  
  2059.     /* NOTE: Must use 2 steps because must blit (possibly part of) loaded */
  2060.     /*  image of arbitrary size, adjusting for GZZ borders, and from plane 0 */
  2061.     /*  to plane 1. Neither BltBitMap nor BltTemplate can do this in 1 step */
  2062.  
  2063.     /* Step 1: Blit plane 0 of loaded image to temp bitmap  */
  2064.     /*         (uses outline buffer as its single bitplane) */
  2065.     InitBitMap(&tmpbitmap, 1L, WIDTH, HEIGHT);
  2066.     tmpbitmap.Planes[0] = (PLANEPTR)outlinebufptr;
  2067.  
  2068.     blitbuffer = (char *)AllocMem(80L,MEMF_CHIP); /* Allocate temp buffer */
  2069.     BltBitMap(&picbitmap, 0L, 0L, &tmpbitmap, 0L, 0L,
  2070.      MIN(WIDTH, picbitmap.BytesPerRow*8L),
  2071.      MIN(HEIGHT, picbitmap.Rows), 192L, 0x1, blitbuffer);
  2072.      /* 192L is minterm for Direct Copy; 0x1 is mask, will copy plane 0 */
  2073.     FreeMem(blitbuffer, 80L);
  2074.  
  2075.     /* Step 2: Blit the temporary bitplane from Outline Buffer to plane 1 */
  2076.     /*         of GZZ Window */
  2077.  
  2078.     SetAPen(r, 2L);
  2079.     SetDrMd(r, JAM1);
  2080.     SetWrMsk(r,0x0002);  /* Write protect all planes except plane 1 */
  2081.     BltTemplate((char*)outlinebufptr, 0L, WIDTH/8L, Window->RPort, 0L, 0L, 
  2082.      MIN(GZZWIDTH, picbitmap.BytesPerRow*8L), MIN(GZZHEIGHT, picbitmap.Rows));
  2083.     SetWrMsk(r,0xFFFF);
  2084.  
  2085.     exists_outline = 1;
  2086.     break;
  2087.  
  2088.   case 1:   /***  Set up a (new) Image Screen and blit loaded image into it */
  2089.     if (exists_image)
  2090.       CloseImageScreen();
  2091.     OpenImageScreen(iFrame.bmHdr.pageWidth, iFrame.bmHdr.pageHeight,
  2092.                                                             picbitmap.Depth);
  2093.  
  2094.     /* Link colours read in from file to screen's ViewPort */  
  2095.     LoadRGB4(&(ImageScreen->ViewPort), iFrame.colorMap, 1<<picbitmap.Depth);
  2096.  
  2097.     SetWindowTitles(ImageWindow,
  2098.                (char *)" ", (char *)" Click in screen to push it back");
  2099.     blitbuffer = (char *)AllocMem(80L,MEMF_CHIP); /* Allocate temp buffer */
  2100.     BltBitMap(&picbitmap, 2L, 11L, ImageWindow->RPort->BitMap, 2L, 11L,
  2101.      MIN(ImageWindow->Width-4L,picbitmap.BytesPerRow*8L-2L),
  2102.      MIN(ImageWindow->Height-13L,picbitmap.Rows-11L), 192L, 0xFF, blitbuffer);
  2103.      /* 192L is minterm for Direct Copy; 0xFF is mask, will copy all planes */
  2104.      /* 2L, 11L, 4L, 13L cause The blit to skip the window borders */
  2105.     FreeMem(blitbuffer, 80L);
  2106.     exists_image = 1;
  2107.     break;
  2108.   }       /* End switch dest */
  2109.  
  2110.   if (picbitmap.Planes[0])  /* free planes allocated by ReadPicture, if any */
  2111.     RemFree(picbitmap.Planes[0]);
  2112.   ModifyMousePtr(Window, -1);   /* Remove 'ZZ' pointer */
  2113. }
  2114. /*==========================================================================*/
  2115.  
  2116. AboutText(whichtext)   /* Opens the text screen and displays in it */
  2117. int whichtext;         /* the selected About text or IFS code table */
  2118.                        /* according to whichtext. Closes on click in screen */
  2119.        /* whichtext can be: CODES, IFS_THEORY, HELP1, HELP2, AUTHOR, DEMOTEXT*/
  2120. {
  2121.   struct Screen *TextScreen;
  2122.   struct Window *TextWindow;
  2123.   struct NewScreen ns;
  2124.   struct Screen *OpenScreen();
  2125.   struct NewWindow nw;
  2126.   struct Window *OpenWindow();
  2127.   struct Message * GetMsg();
  2128.   struct IntuiMessage *message;
  2129.   static struct IntuiText RedText = {
  2130.     3, 0, JAM1,        /* FrontPen, BackPen, DrawMode */
  2131.     0, 0,              /* LeftEdge, TopEdge */
  2132.     &TOPAZ80,          /* ITextFont */
  2133.     (UBYTE*)"Click Mouse to Continue", NULL  /* IText, NextText */
  2134.   };
  2135.   char codelinebuf[78];   /* Buffer for line of codes in CODES display */
  2136.   static struct IntuiText CodesText = {     /* Codes line for display */
  2137.     1, 0, JAM1,        /* FrontPen, BackPen, DrawMode */
  2138.     0, 0,              /* LeftEdge, TopEdge */
  2139.     &TOPAZ80,          /* ITextFont */
  2140.     NULL, NULL  /* IText, NextText */
  2141.   };
  2142.  
  2143.   /*** Open a window in a custom Hires screen for text display */
  2144.  
  2145.   ns.LeftEdge = 0;      /*** Initialize NewScreen structure */
  2146.   ns.TopEdge = 0;
  2147.   ns.Width = 640;
  2148.   ns.Height = 200;
  2149.   ns.Depth = 2;
  2150.   ns.DetailPen = 0;  /* Colour of text in screen title bar */
  2151.   ns.BlockPen = 1;   /* Colour of screen Title Bar */
  2152.   ns.ViewModes = HIRES;
  2153.   ns.Type = CUSTOMSCREEN;
  2154.   ns.Font = &TOPAZ80;
  2155.   ns.DefaultTitle = NULL;
  2156.   ns.Gadgets = NULL;
  2157.   ns.CustomBitMap = NULL;
  2158.  
  2159.   nw.LeftEdge = 0;         /*** Initialize NewWindow structure */
  2160.   nw.TopEdge = 0;
  2161.   nw.Width = 640;
  2162.   nw.Height = 200;
  2163.   nw.DetailPen = 0; /* Menu title text color */
  2164.   nw.BlockPen  = 1; /* Menu item box and title bar background */
  2165.   nw.IDCMPFlags = MOUSEBUTTONS;
  2166.   nw.Flags = ACTIVATE|SIMPLE_REFRESH;
  2167.   nw.FirstGadget = NULL;
  2168.   nw.CheckMark = NULL;
  2169.   nw.Title = (UBYTE*)" ";
  2170.   nw.Screen = NULL;  /* Will set it to TextScreen after the screen is opened */
  2171.   nw.BitMap = NULL;
  2172.   nw.MinWidth = 0;
  2173.   nw.MinHeight = 0;
  2174.   nw.MaxWidth = 0;
  2175.   nw.MaxHeight = 0;
  2176.   nw.Type = CUSTOMSCREEN;
  2177.  
  2178.   /*** Open the screen */
  2179.   if ((TextScreen = (struct Screen *) OpenScreen(&ns)) == NULL) {
  2180.     ShowError("Couldn't open Text screen!!!");
  2181.     return;
  2182.   }
  2183.  
  2184.   /*** Open the Window */
  2185.   nw.Screen = TextScreen;
  2186.   if ((TextWindow = (struct Window *) OpenWindow(&nw)) == NULL) {
  2187.     CloseScreen(TextScreen);
  2188.     ShowError("Couldn't open Text window!!!");
  2189.     return;
  2190.   }  
  2191.   Textrp = (TextWindow->RPort);  /* Window's rastport, used by p() */
  2192.  
  2193.   p(NULL);  /* reset screen print routine to top of screen */
  2194.   p(" ");   /* skip 2 lines to clear text window title bar */
  2195.   p(" ");
  2196.  
  2197.   switch (whichtext) {   /**** Print appropreiate text into window */
  2198.  
  2199.   case IFS_THEORY:
  2200.     SetWindowTitles(TextWindow,  " IFS Theory Background", -1L);
  2201.  
  2202. p("   IFS is a method developed by Michael F. Barnsley that allows one to en\
  2203. code a");
  2204. p(" Fractal as a small set of numbers, the coefficients of an Iterated Funct\
  2205. ion");
  2206. p(" System (IFS) Code, and later to reconstruct it from those numbers. An IF\
  2207. S Code");
  2208. p(" is a set of Contractive Affine Transformations, which are transformation\
  2209. s of");
  2210. p(" the plane that combine a Linear Transformation (consisting of combinatio\
  2211. ns of");
  2212. p(" stretching and rotation) and a Translation of the origin. Each such affi\
  2213. ne");
  2214. p(" transformation can be represented by six real numbers. In addition, with\
  2215.  each");
  2216. p(" transformation is associated a probability value.");
  2217. p(" ");
  2218. p("   To derive the IFS Code for a given Fractal image, one must find a set \
  2219. of");
  2220. p(" transformations of the image - reduced, deformed copies of it - that whe\
  2221. n");
  2222. p(" taken together cover the original image. To reconstruct  the image, one \
  2223. starts");
  2224. p(" with any point in the plane,  picks at random one of the transformations");
  2225. p(" defined above, applies it to the point, and draws the resulting point. T\
  2226. o this");
  2227. p(" new point one applies the same procedure, and so on. The probabilities d\
  2228. efine");
  2229. p(" how often each transformation will be picked. The 'Collage Theorem' assu\
  2230. res");
  2231. p(" that this process will in fact reconstruct the original Fractal.");
  2232. p(" ");
  2233. p("   For more detailed information on the theory and use of IFS, refer to:");
  2234. p("    - Barnsley and Sloan: A Better Way to Compress Images, BYTE, Jan. 88\
  2235. .");
  2236. p("    - Peitgen and Saupe, eds.: The Science of Fractal Images, Chapter 5.");
  2237.  
  2238.     break;
  2239.  
  2240.   case HELP1:
  2241.     SetWindowTitles(TextWindow,  " A Summary of Program Operation", -1L);
  2242.  
  2243. p(" This program requires two steps to generate an IFS Code for a Fractal:");
  2244. p(" ");
  2245. p(" a. OUTLINE EDITOR: This step allows you to draw the approximate Outline \
  2246. of");
  2247. p("  the planned Fractal. The user interface is a simple Paint program, with");
  2248. p("  Freestyle, Lines, Erase (XXX), Fill and Clear gadgets. Note that the le\
  2249. ss");
  2250. p("  pixels you draw, the faster things will move later, in the Collage Edit\
  2251. or");
  2252. p("  phase. When your Outline is finished, click DONE to enter the Collage E\
  2253. ditor.");
  2254. p(" ");
  2255. p(" b. COLLAGE EDITOR: Here you create the Collage, by defining the affine");
  2256. p("  transformations ('Pieces') to cover the Outline with. When you enter th\
  2257. is");
  2258. p("  mode, you see your Outline, and one Default transformation - a half-siz\
  2259. ed");
  2260. p("  copy of this Outline, drawn in red. The box around it is the image of t\
  2261. he");
  2262. p("  screen boundary under the transformation. You can modify the Piece by");
  2263. p("  dragging any corner of this box with the mouse. The corner marked 'O' w\
  2264. ill");
  2265. p("  translate the Origin; 'X' and 'Y' will stretch and rotate these axes; T\
  2266. he");
  2267. p("  last corner will enlarge and rotate the Piece without deforming it. Cli\
  2268. ck");
  2269. p("  ADD to add a new Default Piece, or DUP to add a duplicate of the curren\
  2270. t");
  2271. p("  Piece. The Piece drawn in red is the 'Selected' one; all editing action\
  2272. s");
  2273. p("  apply to it. Clicking SEL repeatedly will make one Piece after another \
  2274. the");
  2275. p("  Selected one, allowing you to modify (or delete, by clicking DEL) previ\
  2276. ously");
  2277. p("  defined Pieces.");
  2278.  
  2279.     break;
  2280.  
  2281.   case HELP2:
  2282.     SetWindowTitles(TextWindow, " A Summary of Program Operation (Continued)",
  2283.                                                                           -1L);
  2284.  
  2285. p("    You can click the NUM gadget to get a numeric display of the Selected");
  2286. p("  transformation's coefficients (a-f, p), as well as the associated Proba\
  2287. bility");
  2288. p("  Density (probability per unit area) and Scalings, Rotations and Transla\
  2289. tions.");
  2290. p("  You can modify any one of these values in their string gadgets, and cli\
  2291. ck");
  2292. p("  ENTER to make the changes take effect. To quit the numeric window, clic\
  2293. k its");
  2294. p("  Close gadget.");
  2295. p(" ");
  2296. p("    When you've covered the Outline fully with Pieces, use the Render men\
  2297. u");
  2298. p("  to generate the Attractor of the IFS in the resolution and gray level c\
  2299. ount");
  2300. p("  of your choice.");
  2301. p(" ");
  2302. p("    The Optimize menu item will modify the current IFS so that its Attrac\
  2303. tor");
  2304. p("  will fill the screen; it will also generate an exact Collage for it, by\
  2305.  using");
  2306. p("  the Attractor itself as an Outline.");
  2307. p(" ");
  2308. p("    File I/O menuitems allow you to save the IFS codes or the Image to d\
  2309. isk,");
  2310. p("  to load IFS Codes from files saved by IFSLab and by most other IFS prog\
  2311. rams,");
  2312. p("  and to load any Non-HAM IFF image file into the Image screen or as the");
  2313. p("  Outline.");
  2314.     break;
  2315.  
  2316.   case AUTHOR:
  2317.     SetWindowTitles(TextWindow,  "  Author Information", -1L);
  2318. p(" ");
  2319. p(" ");
  2320. p(" ");
  2321. p(" ");
  2322. p("                       IFS Lab written by Nathan Zeldes");
  2323. p(" ");
  2324. p(" ");
  2325. p("              Copyright (C) 1992 by N. Zeldes. All Rights Reserved. ");
  2326. p(" ");
  2327. p("           Thanks to C.W. Fox and Bruce Dawson for the File Requester");
  2328. p(" ");
  2329. p(" ");
  2330. p("                                                                       ");
  2331. p(" ");
  2332. p(" ");
  2333. p(" ");
  2334.  
  2335.     break;
  2336.  
  2337.   case DEMOTEXT:  
  2338.     SetWindowTitles(TextWindow,  " A Demonstration of IFS in Action", -1L);
  2339.  
  2340. p(" ");
  2341. p("   This demo will define and render the Sierpinski Triangle, a well known");
  2342. p(" fractal.");
  2343. p(" ");
  2344. p("   The program will first enter the Outline Editor and draw an Outline of\
  2345.  the");
  2346. p(" Sierpinski triangle. After a brief delay it will switch to the Collage E\
  2347. ditor");
  2348. p(" and show how the Outline can be covered by three half-sized copies of it\
  2349. self.");
  2350. p(" When it has built this Collage, the program will initiate rendering of t\
  2351. he");
  2352. p(" fractal. Note that this demo intentionally assigns unequal probabilities\
  2353.  to");
  2354. p(" the three transformations, which causes the uneven 'shading' effect in t\
  2355. he");
  2356. p(" rendered image.");
  2357. p(" ");
  2358. p("   To start the demo, click the left mouse button.  Do no more until the"); 
  2359. p(" rendering begins. When you've had your fill of the beauty of the emergin\
  2360. g");
  2361. p(" image, click twice in the Image screen to exit the demo.");
  2362.  
  2363.     break;
  2364.  
  2365.   case CODES:    /* Display Codes Table */
  2366.     SetWindowTitles(TextWindow,  " IFS Code Coefficients", -1L);
  2367.  
  2368.     p("    A      B      C      D     E     F     P     Dens   S1    S2\
  2369.     R1    R2 ");
  2370.     if (N < MAX_N)
  2371.       p(" ------ ------ ------ ------ ----- ----- ----- ------- ----- -----\
  2372.  ----- ----- ");   /* The underline is omitted to allow display of 20 pieces */
  2373.  
  2374.     for(i = 0; i <= N; i++) {    /* Put lines of coefficients in text window */
  2375.  
  2376.       sprintf(codelinebuf, " % 6.3lf % 6.3lf % 6.3lf % 6.3lf %5.3lf %5.3lf\
  2377.  %5.3lf %7.3lf% 5.3lf %5.3lf % 4.0lf  % 4.0lf", pieceptr[i]->a, pieceptr[i]->b,
  2378.        pieceptr[i]->c, pieceptr[i]->d, pieceptr[i]->e, pieceptr[i]->f,
  2379.        pieceptr[i]->p, pieceptr[i]->dens, pieceptr[i]->s1, pieceptr[i]->s2,
  2380.        pieceptr[i]->r1/0.017453293, pieceptr[i]->r2/0.017453293); 
  2381.  
  2382.       CodesText.FrontPen = (i == selpiece) ? 3 : 1; /* Selected piece in red */
  2383.       CodesText.IText = (UBYTE*)codelinebuf;
  2384.       CodesText.TopEdge = (N < MAX_N) ? 8L * i + 32L : 8L * i + 24L;
  2385.       PrintIText(Textrp, &CodesText, 0L, 0L);
  2386.     }
  2387.     break;
  2388.  
  2389.   }  /* End switch */
  2390.  
  2391.   PrintIText(Textrp, &RedText, 450L, 190L); /* 'Click Mouse...' text */
  2392.  
  2393.   /*** Wait with text displayed, poll IDCMP until you get a SELECTDOWN */
  2394.   while (!(message = (struct IntuiMessage *)GetMsg(TextWindow->UserPort))) 
  2395.     ;   /* here any event must be a SELECTDOWN due to IDCMP flag definition */
  2396.   ReplyMsg(message);
  2397.   while (!(message = (struct IntuiMessage *)GetMsg(TextWindow->UserPort))) 
  2398.     ;    /* get rid of SELECTUP message following the SELECTDOWN */
  2399.   ReplyMsg(message);
  2400.  
  2401.   CloseWindow(TextWindow);   /* Close text display and return */
  2402.   CloseScreen(TextScreen);
  2403. }
  2404. /*===========================================================================*/
  2405.  
  2406. PutDefOutline()  /* Place default Outline in Outline Bitmap */
  2407. {
  2408.   ModifyMousePtr(Window, 1);   /* Bring up 'ZZ' pointer */
  2409.   SetDrMd(r, JAM1);
  2410.   SetAPen(r, 2L);
  2411.   SetOPen(r, 2L);
  2412.   SetWrMsk(r,0x0002);  /* Write protect all planes except plane 1 */
  2413.   SetRast(r, 0L);
  2414.  
  2415.   DrawCircle(r, 138L, 93L, 22L);   /* Face outline */
  2416.   DrawCircle(r, 138L, 93L, 13L);   /* To become mouth outline */
  2417.   SetAPen(r, 0L);
  2418.   SetOPen(r, 0L);
  2419.   RectFill(r, 124L, 80L, 152L, 100L); /* Blot out top part of mouth circle */
  2420.   SetAPen(r, 2L);
  2421.   SetOPen(r, 2L);
  2422.   DrawCircle(r, 129L, 85L, 3L);   /* Left Eye */
  2423.   DrawCircle(r, 147L, 85L, 3L);   /* Right Eye */
  2424.  
  2425.   exists_outline = 1;
  2426.   SetWrMsk(r,0xFFFF);
  2427.   ModifyMousePtr(Window, -1);   /* Remove 'ZZ' pointer */
  2428. }
  2429. /*===========================================================================*/
  2430.  
  2431. TransformPiece(source, dest, pc)      /* Apply transformation of Piece */
  2432.      /* To image in source bitplane, put result in dest piecemap. */
  2433.      /* Return 1 if done OK, return 0 if a pixel overflowed plane boudary. */
  2434.      /* Any overflow pixels are not put into the destination piecemap. */
  2435.      /* Skips title bar and borders of source bitplane properly. */
  2436.      /* Replaces doubles with scaled-up integers for speed. */
  2437.  
  2438. UBYTE *source;      /* Pointer to 1st byte in a single Window-sized Bitplane */
  2439. UBYTE *dest;        /* Pointer to first byte in target piecemap */
  2440. struct piece *pc;   /* pointer to piece structure containing trans' coeffs */
  2441. {
  2442.   #define LEFTBDRBITS     4  /* Width in BITS of left border of Window */
  2443.   #define TOPBDRBYTES   440  /* bytes within Top Border of Window */
  2444.   #define RIGHTBDRBYTES   5  /* bytes within right Border (must be integral) */
  2445.   #define MAPROWBYTES    35  /* Number of bytes in a net row of piecemap */
  2446.   #define MAPROWBYTESPLUS 40 /* Number of bytes in a gross row of piecemap */
  2447.   #define PIECEMAPWIDTH  GZZWIDTH+Window->BorderLeft
  2448.  
  2449.   UBYTE *srcbyte;      /* address of current byte in source bitplane */
  2450.   int bitpos;     /* bit position in byte (leftmost bit = 0) */
  2451.   int rowbyte;   /* number of current source byte within row */
  2452.   int srcx, srcy, destx, desty;  /* Source and destination pixel X-Y coords */
  2453.   long ai, bi, ci, di, ei, fi; /* Scaled integer transformation coefficients */
  2454.   long lbdri;   /* Scaled LEFTBDRBITS */
  2455.   int overflowflag = 0;
  2456.  
  2457.   ModifyMousePtr(Window, 1);   /* Bring up 'ZZ' pointer */
  2458.   /* Erase piecemap */
  2459.   BltClear((char*)dest, (long)RASSIZE(WIDTH,GZZHEIGHT), 1L);
  2460.  
  2461.   /*** Convert coefficients to scaled integers */
  2462.  
  2463.   ai = (long)(pc->a * 1000000);
  2464.   bi = (long)(pc->b * 1000000);
  2465.   ci = (long)(pc->c * 1000000);
  2466.   di = (long)(pc->d * 1000000);
  2467.   ei = (long)(pc->e * 1000000 * GZZWIDTH);
  2468.   fi = (long)(pc->f * 1000000 * GZZWIDTH);
  2469.   lbdri = (long)(LEFTBDRBITS * 1000000);
  2470.  
  2471.   srcbyte = source + TOPBDRBYTES;  /* Initialize srcbyte to after Top Border */
  2472.  
  2473.   for (srcy = 0; srcy < GZZHEIGHT; srcy++) {   /* Loop on source plane rows */
  2474.     /* Loop on bytes in source row - up to right border only */
  2475.     for (rowbyte = 0; rowbyte < MAPROWBYTES; rowbyte++) {
  2476.  
  2477.       if (*srcbyte != 0) {    /* If Source byte not empty */
  2478.  
  2479.         for(bitpos = 0; bitpos < 8; bitpos++) { /* loop on bits in byte */
  2480.           if ((*srcbyte & (128>>bitpos)) != 0) { /* current src pixel is '1' */
  2481.  
  2482.             srcx = rowbyte * 8 + bitpos - LEFTBDRBITS;
  2483.  
  2484.             /* do transformation */
  2485.             destx = (ai * srcx + bi * srcy + ei + lbdri) / 1000000;
  2486.             desty = (ci * srcx + di * srcy + fi) / 1000000;
  2487.  
  2488.             if(destx < LEFTBDRBITS || destx >= PIECEMAPWIDTH ||
  2489.              desty < 0 || desty >= GZZHEIGHT)     /* Don't write transformed */
  2490.               overflowflag = 1;  /* pixel to dest - it is outside  bitplane! */
  2491.             else 
  2492.               /* write '1' pixel to destination. Expression to left of |=  */
  2493.               /* is destination byte address;  128>>bitpos is the bitmask. */
  2494.               *( dest + desty*MAPROWBYTESPLUS + destx/8 ) |= 128>>(destx % 8);
  2495.           }  /* End if current source pixel is '1' */
  2496.         }    /* End loop on bits in byte */
  2497.       }      /* End If source byte not empty */
  2498.       srcbyte++;
  2499.     }        /* End loop on bytes in source row */
  2500.     srcbyte += RIGHTBDRBYTES;   /* skip right border */
  2501.   }          /* End loop on source rows */
  2502.   ModifyMousePtr(Window, -1);   /* Remove 'ZZ' pointer */
  2503.   return(!overflowflag);
  2504. }
  2505. /*===========================================================================*/
  2506.  
  2507. SaveIFS()    /* Save IFS coefficients, if any, to a disk file */
  2508. {
  2509.   FILE *fopen(), *fp;
  2510.   char *fnam, *p;
  2511.   char *GetFileName();
  2512.   int strcmp();
  2513.   char *strcat();
  2514.   long k;
  2515.   
  2516.   if (drawmode != VECTOR) {
  2517.     ShowError("No IFS to Save!");
  2518.     return;
  2519.   }
  2520.   /*** Open disk file,deleting prev rev if any; if error, exit function */
  2521.  
  2522.   fnam = GetFileName("Save to File:");
  2523.   if (*fnam == '\0') {
  2524.     return;  /* do nothing - user selected CANCEL or no filename */
  2525.   }
  2526.  
  2527.   k = 0;      /* Set k to 1 if filename ends with .ifs */
  2528.   for (p = fnam; *p != '\0'; p++)
  2529.     if (strcmp(p, ".ifs") == 0)
  2530.       k = 1;
  2531.   if (k == 0)      /* Add .ifs to filename if needed */
  2532.     strcat(fnam, ".ifs");
  2533.  
  2534.   if ((fp = fopen(fnam, "w")) == NULL) {
  2535.     ShowError(" Cannot open file!!!");
  2536.     return;
  2537.   }
  2538.  
  2539.   /*** Save the current IFS codes to a disk file */
  2540.  
  2541.   fprintf(fp, "    A      B      C      D     E     F     P      Dens   S1\
  2542.     S2    R1    R2\n");
  2543.   for(i = 0; i <= N; i++)
  2544.       fprintf(fp, " % 6.3lf % 6.3lf % 6.3lf % 6.3lf %5.3lf %5.3lf\
  2545.  %5.3lf %7.3lf% 5.3lf %5.3lf % 4.0lf  % 4.0lf\n", pieceptr[i]->a,
  2546.        pieceptr[i]->b, pieceptr[i]->c, pieceptr[i]->d, pieceptr[i]->e,
  2547.        pieceptr[i]->f, pieceptr[i]->p, pieceptr[i]->dens, pieceptr[i]->s1,
  2548.        pieceptr[i]->s2, pieceptr[i]->r1/0.017453293,
  2549.        pieceptr[i]->r2/0.017453293); 
  2550.  
  2551.   fclose(fp);         /* close disk file */
  2552. }
  2553. /*===========================================================================*/
  2554.  
  2555. int LoadIFS(fnam)   /* Load IFS Code variables from disk file */
  2556. char *fnam;         /* Returns 1 if done OK, 0 if failed to load */
  2557.                     /* Skips lines of wrong form (e.g. text headers) */
  2558.                     /* and ignores excess info on a line (e.g. Geom. Coeffs) */
  2559.                     /* Calls Optimize() to create a Collage and assure */
  2560. {                   /* Attractor will not overflow window */
  2561.   FILE *fopen(), *fp;
  2562.   int c, eofread, scan;
  2563.   char linebuf[161];  /* Input lines will be truncated after 160 chars */
  2564.   double mindens;
  2565.   long xmin, xmax, ymin, ymax;
  2566.            /* GZZ PIXEL coords of boundary rect of old (as-loaded) attractor*/
  2567.   int j;
  2568.  
  2569.   /*** Open disk file for reading */
  2570.   if ((fp = fopen(fnam,"r")) == NULL) {
  2571.     ShowError(" Cannot open file!!!");
  2572.     return(0);
  2573.   }
  2574.  
  2575.   ClearIFS();   /* Erase old IFS (if any), set N to -1 */
  2576.  
  2577.   /*** Load the IFS codes line by line */
  2578.  
  2579.   eofread = 0;
  2580.   while (N < MAX_N && !eofread) {  /* Loop on lines in file */
  2581.  
  2582.     if ((pieceptr[++N] = AllocPiece()) == NULL) {  /* Allocate Piece */
  2583.       N--;         /* if couldn't allocate piece */
  2584.       ShowError("Couldn't allocate memory!");
  2585.       if (N == -1) {    /* No memory for even one Piece - Quit program */
  2586.         ShowError("Re-run with more free memory!");
  2587.         CloseAll();
  2588.       }
  2589.       ShowError("        Aborting Load!         ");
  2590.       fclose(fp);
  2591.       return(0);
  2592.     }
  2593.  
  2594.     /*** Read in a single line from file into memory, then sscanf it */
  2595.     /* (Don't use fscanf from file because it ignores end of line */
  2596.     for (i = 0; i < 160 && (c = getc(fp)) != EOF && c != '\n'; i++)
  2597.       linebuf[i] = c;
  2598.     linebuf[i] = '\0';
  2599.     if (c != EOF && c != '\n')  /* Line has been truncated after 160 chars */
  2600.       while ((c = getc(fp)) != '\n' && c != EOF)
  2601.         ;                   /* Remove any other stuff on the file line */ 
  2602.     if (c == EOF)
  2603.       eofread = 1;
  2604.    
  2605.     /* Now a null-terminated line is in linebuf & the file is positioned at */
  2606.     /* start of next file line or past EOF;eofread is set if EOF was reached */
  2607.  
  2608.     scan = sscanf(linebuf, "%lf %lf %lf %lf %lf %lf %lf", &pieceptr[N]->a,
  2609.             &pieceptr[N]->b, &pieceptr[N]->c, &pieceptr[N]->d, &pieceptr[N]->e,
  2610.             &pieceptr[N]->f, &pieceptr[N]->p);
  2611.  
  2612.     if (scan == 7) {   /* converted successfully 7 coeffs of one IFS */
  2613.  
  2614.       /*** Check that coefficients a - d and p are in legal ranges */
  2615.       if (pieceptr[N]->a < -1. || pieceptr[N]->a > 1. || pieceptr[N]->b < -1.||
  2616.        pieceptr[N]->b > 1. || pieceptr[N]->c < -1. || pieceptr[N]->c > 1. ||
  2617.        pieceptr[N]->d < -1. || pieceptr[N]->d > 1. || 
  2618.        pieceptr[N]->p <= 0. || pieceptr[N]->p > 1.) {
  2619.         ShowError("Coefficient out of Range!");
  2620.         ShowError("      Aborting Load!     ");
  2621.         fclose(fp);
  2622.         return(0);
  2623.       }
  2624.  
  2625.       /*** compute the geometrical coeffs from matrix coeffs read from file */
  2626.       pieceptr[N]->s1 = sqrt(pieceptr[N]->a*pieceptr[N]->a +
  2627.                                             pieceptr[N]->c*pieceptr[N]->c);
  2628.       pieceptr[N]->s2 = sqrt(pieceptr[N]->b*pieceptr[N]->b +
  2629.                                             pieceptr[N]->d*pieceptr[N]->d);
  2630.       pieceptr[N]->r1 = myatan2(pieceptr[N]->c, pieceptr[N]->a);
  2631.       pieceptr[N]->r2 = myatan2(-pieceptr[N]->b, pieceptr[N]->d);
  2632.       pieceptr[N]->det = fabs(pieceptr[N]->a * pieceptr[N]->d -
  2633.                                          pieceptr[N]->b * pieceptr[N]->c);
  2634.       if (pieceptr[N]->det == 0.0)
  2635.         pieceptr[N]->det = 0.01;
  2636.       pieceptr[N]->dens = pieceptr[N]->p / pieceptr[N]->det;
  2637.  
  2638.       /*** Compute new Box corners from new coeffs */
  2639.       pieceptr[N]->boxo.x = pieceptr[N]->e * GZZWIDTH;
  2640.       pieceptr[N]->boxo.y = pieceptr[N]->f * GZZWIDTH; /* sic! */
  2641.       pieceptr[N]->boxx.x = (pieceptr[N]->a + pieceptr[N]->e) * GZZWIDTH;
  2642.       pieceptr[N]->boxx.y = (pieceptr[N]->c + pieceptr[N]->f) * GZZWIDTH;
  2643.       pieceptr[N]->boxy.x = (pieceptr[N]->b * GZZHEIGHT/GZZWIDTH +
  2644.          pieceptr[N]->e) * GZZWIDTH;
  2645.       pieceptr[N]->boxy.y = (pieceptr[N]->d * GZZHEIGHT/GZZWIDTH +
  2646.          pieceptr[N]->f) * GZZWIDTH;
  2647.       pieceptr[N]->boxz.x = pieceptr[N]->boxy.x + pieceptr[N]->boxx.x -
  2648.          pieceptr[N]->boxo.x;
  2649.       pieceptr[N]->boxz.y = pieceptr[N]->boxy.y + pieceptr[N]->boxx.y -
  2650.          pieceptr[N]->boxo.y;
  2651.     }
  2652.  
  2653.     else    /* scanf failed to match 7 doubles on line - skip it! */
  2654.       FreePiece(pieceptr[N--]);
  2655.  
  2656.   }    /* End while loop on lines */
  2657.  
  2658.   selpiece = N;
  2659.  
  2660.   if (N == MAX_N && !eofread && getc(fp) != EOF)  /* Exited loop at N==MAX_N */
  2661.     ShowError("File too long; IFS may be truncated");
  2662.  
  2663.   if (N == -1) {   /* Not a single transformation was found! */
  2664.     ShowError("No IFS found in File - Aborting Load!");
  2665.     fclose(fp);
  2666.     return(0);
  2667.   }
  2668.  
  2669.   /*** If probabilities read from file were cumulative, convert to non-cum */
  2670.   if (pieceptr[N]->p == 1.000) {
  2671.     for (i = N; i > 0; i--) {
  2672.       pieceptr[i]->p = pieceptr[i]->p - pieceptr[i-1]->p;
  2673.       pieceptr[i]->dens = pieceptr[i]->p / pieceptr[i]->det;
  2674.     }
  2675.   }
  2676.  
  2677.   /*** Normalize Piece densities so smallest one is 1.000 */
  2678.   mindens = 1000000.;
  2679.   for (i = 0; i <= N; i++)
  2680.     if (pieceptr[i]->dens < mindens)
  2681.       mindens = pieceptr[i]->dens;
  2682.   for (i = 0; i <= N; i++)
  2683.     pieceptr[i]->dens /= mindens;
  2684.  
  2685.   ComputeProbs(); /* Adjust all probabilities in case rounding errors in */
  2686.                   /* file made their sum != 1.000 */
  2687.  
  2688.   fclose(fp);         /* close disk file */
  2689.  
  2690.   /* Transform loaded IFS to fit in window if it exceeds it, */
  2691.   /* and generate Collage */
  2692.   Optimize(0);
  2693.  
  2694.   return(1);
  2695. }
  2696. /*===========================================================================*/
  2697. int Optimize(mode) /* Creates an Outline from current Attractor, creates    */
  2698. int mode;          /* a Collage from it and displays it. If mode==1, also   */
  2699.                    /* modifies the IFS so its attractor fills the window.   */
  2700.                    /* If mode==0, does this only if current Attractor would */
  2701.                    /* overflow the window.                                  */
  2702.                    /* Returns 1 if successful and 0 if it failed (because   */
  2703. {                  /* not in Collage Editor) and no modifications were done.*/
  2704.   long xmin, xmax, ymin, ymax;  /* GZZ PIXEL coords of old boundary rect */
  2705.   int px1, py1; /* GZZ PIXEL coords  of Topleft corner of new boundary rect */
  2706.   double x0,y0; /* REAL plane coords of Topleft corner of old boundary rect */
  2707.   double x1,y1; /* REAL plane coords of Topleft corner of new boundary rect */
  2708.   double m;     /* Magnification to apply to attractor so it fills window */
  2709.   double attrw, attrh;  /* PIXEL Width & Height of old boundary rect */
  2710.   struct piece tmppiece;  /* will be used to hold temporary trans' coeffs */
  2711.   int j;
  2712.  
  2713.   if (drawmode != VECTOR) {     /* Abort if not in Collage Editor! */
  2714.     ShowError("No IFS!");
  2715.     return(0);
  2716.   }
  2717.  
  2718.   ModifyMousePtr(Window, 1);   /* Bring up 'ZZ' pointer */
  2719.  
  2720.   SetRast(r, 0L);  /* Erase  Old Outline and Collage */
  2721.  
  2722.   FindBoundary(&xmin, &xmax, &ymin, &ymax); /* Identify old boundary rect */
  2723.  
  2724.   /*** If mode is 1, or mode is 0 but attractor exceeds window, modify IFS ***/
  2725.  
  2726.   if (mode==1 || xmin<0 || xmax >= GZZWIDTH || ymin<0 || ymax >= GZZHEIGHT) {
  2727.     /*** Compute required magnification and relocation of attractor */
  2728.  
  2729.     attrw = (double)((xmax - xmin) + 1);
  2730.     attrh = (double)((ymax - ymin) + 1);
  2731.  
  2732.     if ((double)attrw/(double)attrh >= (double)GZZWIDTH/(double)GZZHEIGHT) {
  2733.       m = 0.95 * (double)GZZWIDTH / attrw;
  2734.       px1 = 0.025 * (double)GZZWIDTH;
  2735.       py1 = 0.025 * (double)GZZHEIGHT +
  2736.                            (0.95 * (double)GZZHEIGHT - m * attrh) / 2.0;
  2737.     }
  2738.     else {
  2739.       m = 0.95 * (double)GZZHEIGHT / attrh;
  2740.       px1 = 0.025 * (double)GZZWIDTH +
  2741.                            (0.95 * (double)GZZWIDTH - m * attrw) / 2.0;
  2742.       py1 = 0.025 * (double)GZZHEIGHT;
  2743.     }
  2744.     x0 = (double)xmin / (double)GZZWIDTH;
  2745.     y0 = (double)ymin / (double)GZZWIDTH;
  2746.     x1 = (double)px1 / (double)GZZWIDTH;
  2747.     y1 = (double)py1 / (double)GZZWIDTH;
  2748.  
  2749.     /*** Modify all piece coefficients to make new attractor fill window */
  2750.  
  2751.     for (i = 0; i <= N; i++) {   /* Loop on pieces */
  2752.       pieceptr[i]->e = m * pieceptr[i]->e + 
  2753.        (pieceptr[i]->a - 1) * (m * x0 - x1) + pieceptr[i]->b * (m * y0 - y1);
  2754.       pieceptr[i]->f = m * pieceptr[i]->f + 
  2755.        pieceptr[i]->c * (m * x0 - x1) + (pieceptr[i]->d - 1) * (m * y0 - y1);
  2756.  
  2757.       /*** Recompute new Box corners from new coeffs */
  2758.       pieceptr[i]->boxo.x = pieceptr[i]->e * GZZWIDTH;
  2759.       pieceptr[i]->boxo.y = pieceptr[i]->f * GZZWIDTH; /* sic! */
  2760.       pieceptr[i]->boxx.x = (pieceptr[i]->a + pieceptr[i]->e) * GZZWIDTH;
  2761.       pieceptr[i]->boxx.y = (pieceptr[i]->c + pieceptr[i]->f) * GZZWIDTH;
  2762.       pieceptr[i]->boxy.x = (pieceptr[i]->b * GZZHEIGHT/GZZWIDTH +
  2763.          pieceptr[i]->e) * GZZWIDTH;
  2764.       pieceptr[i]->boxy.y = (pieceptr[i]->d * GZZHEIGHT/GZZWIDTH +
  2765.          pieceptr[i]->f) * GZZWIDTH;
  2766.       pieceptr[i]->boxz.x = pieceptr[i]->boxy.x + pieceptr[i]->boxx.x -
  2767.          pieceptr[i]->boxo.x;
  2768.       pieceptr[i]->boxz.y = pieceptr[i]->boxy.y + pieceptr[i]->boxx.y -
  2769.        pieceptr[i]->boxo.y;
  2770.     }    /* End loop on pieces */
  2771.   }    /* End if mode==1... */
  2772.  
  2773.   RenderImage(1);   /* Render new attractor in OUTLINE Bitplane */
  2774.   CopyMem((char*)Window->RPort->BitMap->Planes[1], 
  2775.               (char*)outlinebufptr, (long)RASSIZE(WIDTH,HEIGHT));
  2776.   ModifyMousePtr(Window, -1);   /* Remove 'ZZ' pointer */
  2777.  
  2778.   /*** Transform the new Outline (=attractor) into all pieces' piecemaps */
  2779.   /*** Draw each piece into the collage as you go */
  2780.  
  2781.   selpiece = N;
  2782.   for (i = 0; i <= N-1; i++) {  /* Loop on deselected pieces */
  2783.  
  2784.     TransformPiece(outlinebufptr, pieceptr[i]->piecemap, pieceptr[i]);
  2785.  
  2786.     /* Blit this piece from its piecemap to plane 0 */
  2787.     SetWrMsk(r,0x0001);  /* Write protect all planes except plane 0 */
  2788.     SetAPen(r, 1L);
  2789.     BltTemplate((char*)pieceptr[i]->piecemap,(long)Window->BorderLeft,
  2790.         (long)WIDTH/8, r, 0L, 0L, (long)GZZWIDTH, (long)GZZHEIGHT);
  2791.   }
  2792.  
  2793.   /* Now transform Selected Piece & Blit it from piecemap to plane 2 */
  2794.   TransformPiece(outlinebufptr, pieceptr[i]->piecemap, pieceptr[i]);
  2795.   SetWrMsk(r,0x0004);  /* Write protect all planes except plane 2 */
  2796.   SetAPen(r, 4L);
  2797.   BltTemplate((char*)pieceptr[selpiece]->piecemap,(long)Window->BorderLeft,
  2798.    (long)WIDTH/8, r, 0L, 0L, (long)GZZWIDTH, (long)GZZHEIGHT);
  2799.   
  2800.   DrawBox();  /* Draw Vector Box of Selected Piece */
  2801.   /* Note that Rastport's WrMask is restored within DrawBox() */
  2802.  
  2803.   return(1);
  2804. }
  2805. /*===========================================================================*/
  2806.  
  2807. RenderImage(z) /* If z == 0, Render the Attractor in Image Screen at current */
  2808. int z;   /*  resolution & depth settings; stop and return on click in Image */
  2809.          /* screen. If z == 1, render it in Outline bitplane. */
  2810.          /* Probabilities and coefficients are scaled to integers so can use */
  2811.          /* faster integer math */
  2812. {
  2813.   struct Message * GetMsg();
  2814.   struct IntuiMessage *message;
  2815.   int randprob;   /* Random probability value */
  2816.   double sum;        /* cum probability */
  2817.   int k;
  2818.   long unitwidth, unitheight;
  2819.     /* width, height in image screen pixels of unit square in the plane */
  2820.   long iter; /* Iteration counter */
  2821.   struct RastPort *imagerp;  /* Pointer to rastport of Image window */
  2822.   long pix;  /* Color (Pen #) of a pixel */
  2823.   long ReadPixel();
  2824.   long ai[MAX_N+1], bi[MAX_N+1], ci[MAX_N+1],
  2825.        di[MAX_N+1], ei[MAX_N+1], fi[MAX_N+1]; /* Scaled integer coefficients */
  2826.   long xi, yi, tmpxi; /* Scaled integer pixel coordinates */
  2827.   int cumprobi[MAX_N+2];   /* Scaled integer Cum Probabilities */
  2828.      /* cumprobi array has MAX_N+2 elements because using MAX_N+1 caused a */
  2829.      /* Crash for unclear reasons ?!?! */
  2830.  
  2831.     /*** Prepare stuff for iteration loop ***/
  2832.  
  2833.   if (z == 0) {     /* Rendering is in Image Screen */
  2834.     /*** Open Image Window in its screen (Closing any previous image screen) */
  2835.     if (exists_image)
  2836.       CloseImageScreen();
  2837.     OpenImageScreen(renderwidth, renderheight, renderdepth);
  2838.                               /* OpenImageScreen() also opens ImageWindow */
  2839.     imagerp = ImageWindow->RPort; 
  2840.     SetAPen(imagerp,2L); /* Will be modified in loop for Greyscale rendering */
  2841.     SetDrMd(imagerp, JAM1);
  2842.  
  2843.     SetWindowTitles(ImageWindow, -1L,
  2844.                                (char *)" Click in screen to stop rendering");
  2845.  
  2846.     unitwidth = GZZWIDTH*(renderwidth/320); /* GZZWIDTH is of Collage window!*/
  2847.     unitheight = GZZWIDTH * (renderheight/200);
  2848.  
  2849.   }
  2850.   else {   /* Rendering in Outline plane */
  2851.     SetWrMsk(r, 0x0002);  /* Write protect all planes except plane 1 */
  2852.     SetAPen(r, 2L);
  2853.     SetDrMd(r, JAM1);
  2854.     
  2855.     unitwidth = unitheight = GZZWIDTH;
  2856.   }
  2857.  
  2858.   srand((unsigned int)(time(NULL)%10000L));  /* seed random gen from sys time*/
  2859.   
  2860.   sum = 0;
  2861.   for (k = 0; k <= N; k++) {          /* Scale Coefficients as longs */
  2862.     ai[k] = (long)(pieceptr[k]->a * 1000000);
  2863.     bi[k] = (long)(pieceptr[k]->b * 1000000);
  2864.     ci[k] = (long)(pieceptr[k]->c * 1000000);
  2865.     di[k] = (long)(pieceptr[k]->d * 1000000);
  2866.     ei[k] = (long)(pieceptr[k]->e * 1000000 * unitwidth);
  2867.     fi[k] = (long)(pieceptr[k]->f * 1000000 * unitwidth);
  2868.  
  2869.     sum = sum + pieceptr[k]->p;  /* Compute scaled Cum Probabilities */
  2870.     cumprobi[k] = (int)(sum * (double)RAND_MAX);
  2871.   }
  2872.  
  2873.   xi = unitwidth / 3;   /* Initial coordinates */
  2874.   yi = unitwidth / 3;
  2875.  
  2876.     /*** Iterate until user clicks in Image window or until 1000 points ***/
  2877.     /*** (depending on z) ***/
  2878.  
  2879.   for (iter = 0; 1; iter++) {         /* endless loop */
  2880.  
  2881.     /*** Select a Piece at random */
  2882.     randprob = rand();
  2883.                  /* rand() returns a random # (between 0 - RAND_MAX) */
  2884.     for (k = 0; cumprobi[k] < randprob; k++) {
  2885.       /* the following IF is to trap problem case when randprob = RAND_MAX */
  2886.       /* exactly and cum probability is RAND_MAX minus slight delta due to */
  2887.       /* rounding errors */
  2888.       if (k > N) {
  2889.         k--;
  2890.         break;
  2891.       }
  2892.     }
  2893.  
  2894.     /* Apply transformation #k to previous (x,y) */
  2895.     tmpxi = (ai[k] * xi + bi[k] * yi + ei[k]) / 1000000;
  2896.     yi = (ci[k] * xi + di[k] * yi + fi[k]) / 1000000;
  2897.     xi = tmpxi;
  2898.  
  2899.     if (iter > 19) {    /* Render the pixel (except 1st 20 points) */
  2900.  
  2901.       if (z == 0) {   /*** draw in Image Screen, quit on mouseclick in it */
  2902.  
  2903.         if (renderdepth > 1) {  /* Grayscale rendering */
  2904.           pix = ReadPixel(imagerp, xi, yi * unitheight / unitwidth);
  2905.           if (++pix < (1<<renderdepth)) {
  2906.             SetAPen(imagerp, pix);
  2907.             WritePixel(imagerp, xi, yi * unitheight / unitwidth);
  2908.           }
  2909.         }
  2910.         else    /* B&W rendering - A Pen was set outside main loop */
  2911.           WritePixel(imagerp, xi, yi * unitheight / unitwidth);
  2912.  
  2913.         /*** Quit rendering loop if user clicked in ImageWindow */
  2914.         if (message = (struct IntuiMessage *)GetMsg(ImageWindow->UserPort)) {
  2915.           ReplyMsg(message);
  2916.           if (message->Code == SELECTUP) {
  2917.             SetWindowTitles(ImageWindow,
  2918.                      (char *)" Click in screen to push it back", -1L);
  2919.             ShowTitle(ImageScreen, FALSE);  /* Hide screen depth gadgets! */
  2920.             break;  /* From for iter */
  2921.           }
  2922.         }
  2923.       }
  2924.  
  2925.       else {     /* z == 1, draw in outline plane, quit after 1000 iters */
  2926.  
  2927.         WritePixel(r, xi, yi);
  2928.         if (iter > 999)
  2929.           break;  /* From for iter */
  2930.       }
  2931.     }  /* End if iter > 19 */
  2932.   }  /* End for iter */
  2933.  
  2934.   if (z == 0) {  /*** Wait for user click in Image screen to push it to back */
  2935.     while (!(message = (struct IntuiMessage*)GetMsg(ImageWindow->UserPort)))
  2936.       ;       /* Wait for a message */
  2937.     ReplyMsg(message);
  2938.     SetWindowTitles(ImageWindow,
  2939.                (char *)" ", (char *)" Click in screen to push it back");
  2940.     ShowTitle(ImageScreen, TRUE);  /* OK to have depth gadgets now */
  2941.     ScreenToBack(ImageScreen);
  2942.     MoveScreen(ImageScreen, 0L, (long)(-1*ImageScreen->TopEdge));
  2943.     ScreenToFront(Screen);
  2944.     ActivateWindow(Window);
  2945.   }
  2946.   else  /* z == 1, unprotect Outline window planes */
  2947.     SetWrMsk(r, 0xFFFF);
  2948. }
  2949. /*===========================================================================*/
  2950.  
  2951. SaveILBM()    /* Saves the current Image to an IFF disk file */
  2952. {
  2953.   LONG file;  /* File handle [we use AmigaDOS Open(), not Manx open()] */
  2954.   UBYTE *savebuffer;
  2955.   char *fnam;
  2956.  
  2957.   if (exists_image == 0) {
  2958.     ShowError("No Image to save!");
  2959.     return;
  2960.   }
  2961.  
  2962.   fnam = GetFileName("Save to File:");  /* Get the filename */
  2963.   if (*fnam == '\0') /* User selected CANCEL or gave no filename */
  2964.     return;
  2965.  
  2966.   if ((file = Open(fnam, MODE_NEWFILE)) == NULL) {
  2967.     ShowError("Can't open file!");
  2968.     return;
  2969.   }
  2970.   if ((savebuffer = (UBYTE *)AllocMem(8000L, MEMF_CHIP|MEMF_PUBLIC)) == NULL) {
  2971.     ShowError("Can't allocate Save Buffer Memory!");
  2972.     return;
  2973.   }
  2974.  
  2975.   /* Use EA IFF routine PutPict() to save the image to file */
  2976.   ModifyMousePtr(Window, 1);   /* Bring up 'ZZ' pointer */
  2977.   SetWindowTitles(ImageWindow,-1L,
  2978.                               (char *)"");
  2979.   ShowTitle(ImageScreen, FALSE);  /* Hide screen depth gadgets! */
  2980.   ActivateWindow(ImageWindow); /* To make title change take effect */
  2981.   ActivateWindow(Window);
  2982.   PutPict(file, ImageWindow->RPort->BitMap, ImageScreen->Width, ImageScreen->Height,
  2983.    (WORD *)(&(ImageScreen->ViewPort))->ColorMap->ColorTable, savebuffer,8000L);
  2984.   SetWindowTitles(ImageWindow,-1L,
  2985.                               (char *)" Click in screen to push it back");
  2986.   ShowTitle(ImageScreen, TRUE);  /* OK to have depth gadgets now */
  2987.   ActivateWindow(ImageWindow); /* To make title change take effect */
  2988.   ActivateWindow(Window);
  2989.   FreeMem(savebuffer, 8000L);
  2990.   Close(file);
  2991.   ModifyMousePtr(Window, -1);   /* Remove 'ZZ' pointer */
  2992. }
  2993. /*===========================================================================*/
  2994.  
  2995. struct piece *AllocPiece()     /* Allocate memory for a piece structure and */
  2996. {                    /* its piecemap. Return pointer to the piece structure */
  2997.                      /* Or NULL if can't allocate memory */
  2998.   struct piece *tmppieceptr;
  2999.   UBYTE *mapptr;
  3000.  
  3001.   /* Allocate memory for piece structure */
  3002.   if ((tmppieceptr = 
  3003.       (struct piece *)AllocMem((long)sizeof(struct piece), NULL)) == NULL) {
  3004.     ShowError("Can't allocate Memory!");
  3005.     return(NULL);
  3006.   }
  3007.   /* Allocate piecemap CHIP RAM */
  3008.   if ((mapptr = (UBYTE*)AllocRaster((long)WIDTH, (long)GZZHEIGHT)) == NULL) {
  3009.     FreeMem((void*)tmppieceptr, (long)sizeof(struct piece));
  3010.     ShowError("Can't allocate Memory!");
  3011.     return(NULL);
  3012.   }
  3013.   /* Clear piecemap */
  3014.   BltClear((char*)mapptr, (long)RASSIZE(WIDTH,GZZHEIGHT), 1L);
  3015.   tmppieceptr->piecemap = mapptr;   /* Link bitplane to piece structure */
  3016.   return(tmppieceptr);
  3017. }
  3018. /*===========================================================================*/
  3019.  
  3020. FreePiece(piecepntr)          /* Frees the memory used for a piece structure */
  3021. struct piece *piecepntr;      /* and its piecemap. */
  3022. {
  3023.   /* Deallocate CHIP RAM of piecemap bitplane */
  3024.   FreeRaster((void*)(piecepntr->piecemap), (long)WIDTH, (long)GZZHEIGHT);
  3025.  
  3026.   /* Deallocate memory of piece structure */
  3027.   FreeMem((void*)piecepntr, (long)sizeof(struct piece));
  3028. }
  3029. /*===========================================================================*/
  3030.  
  3031. p(text)      /* screen text output routine, similar to BASIC's PRINT */
  3032.              /* puts text in consecutive lines in rastport pointed at by the */
  3033.              /* external pointer Textrp. Line position is maintained between */
  3034.              /* calls, but is reset to top if text==NULL. No overflow check */
  3035. char *text;  /* is done -- text should fit in rastport area! */
  3036. {
  3037.   static struct IntuiText Textline = {
  3038.     1, 0, JAM1,        /* FrontPen, BackPen, DrawMode */
  3039.     0, NULL,            /* LeftEdge, TopEdge */
  3040.     NULL,              /* ITextFont */
  3041.     NULL, NULL            /* IText, NextText */
  3042.   };
  3043.   static int line = 0; /* vert. position of line to be printed next (0 - 24) */
  3044.  
  3045.   if (text == NULL)   /* reset to top line of rastport */
  3046.     line = 0;
  3047.   else {
  3048.     Textline.TopEdge = 8 * line;   /* Put text into line on screen */
  3049.     Textline.IText = (UBYTE*)text;
  3050.     PrintIText(Textrp, &Textline, 0L, 0L);
  3051.     line++;  /* increment line for next call */
  3052.   }
  3053. }
  3054. /*===========================================================================*/
  3055.  
  3056. FindBoundary(xminp, xmaxp, yminp, ymaxp)     /* Iterates IFS without drawing */
  3057.               /* and returns PIXEL coords of boundary rectangle of attractor */
  3058.               /* in variables pointed at by its arguments */ 
  3059.               /* Uses float math, not scaled int, to avoid overflow on very */
  3060.               /* large coeffs of loaded IFS files from other programs */
  3061. long *xminp, *xmaxp, *yminp, *ymaxp;   /* Pointers! */
  3062. {
  3063.   int randprob;   /* Random probability value */
  3064.   double sum;        /* cum probability */
  3065.   int k;
  3066.   long iter; /* Iteration counter */
  3067.   double xd, yd, tmpxd; /* Real pixel coordinates */
  3068.   double xdmin, ydmin, xdmax, ydmax; /* Real boundary rect coords */
  3069.   int cumprobi[MAX_N+2];   /* Scaled integer Cum Probabilities */
  3070.     /* cumprobi array has MAX_N+2 elements because using MAX_N+1 caused a */
  3071.     /* Crash for unclear reasons in RenderImage() ?!?! */
  3072.  
  3073.   /*** Prepare stuff for iteration loop ***/
  3074.  
  3075.   srand((unsigned int)(time(NULL)%10000L));  /* seed random gen from sys time*/
  3076.  
  3077.   sum = 0;
  3078.   for (k = 0; k <= N; k++) {          /* Scale Coefficients as longs */
  3079.     sum = sum + pieceptr[k]->p;  /* Compute scaled Cum Probabilities */
  3080.     cumprobi[k] = (int)(sum * (double)RAND_MAX);
  3081.   }
  3082.  
  3083.   xdmin = 1000000000.;     /* Initialize boundary rectangle coords */
  3084.   xdmax = -1000000000.;
  3085.   ydmin = 1000000000.;
  3086.   ydmax = -1000000000.;
  3087.  
  3088.   xd = 0.3;   /* Initial coordinates */
  3089.   yd = 0.3;
  3090.  
  3091.   /*** Iterate 1000 times without drawing ***/
  3092.  
  3093.   for (iter = 0; iter < 1000; iter++) {
  3094.  
  3095.     /*** Select a Piece at random */
  3096.     randprob = rand();
  3097.                  /* rand() returns a random # (between 0 - RAND_MAX) */
  3098.     for (k = 0; cumprobi[k] < randprob; k++) {
  3099.       /* the following IF is to trap problem case when randprob = RAND_MAX */
  3100.       /* exactly and cum probability is RAND_MAX minus slight delta due to */
  3101.       /* rounding errors */
  3102.       if (k > N) {
  3103.         k--;
  3104.         break;
  3105.       }
  3106.     }
  3107.  
  3108.     /* Apply transformation #k to previous (x,y) */
  3109.     tmpxd = pieceptr[k]->a * xd + pieceptr[k]->b * yd + pieceptr[k]->e;
  3110.     yd = pieceptr[k]->c * xd + pieceptr[k]->d * yd + pieceptr[k]->f;
  3111.     xd = tmpxd;
  3112.  
  3113.     if (iter > 19) {    /* Adjust rectangle  (except 1st 20 points) */
  3114.       if (xd < xdmin)
  3115.         xdmin = xd;
  3116.       if (xd > xdmax)
  3117.         xdmax = xd;
  3118.       if (yd < ydmin)
  3119.         ydmin = yd;
  3120.       if (yd > ydmax)
  3121.         ydmax = yd;
  3122.     }
  3123.  
  3124.   }  /* End for iter */
  3125.  
  3126.   /***  Convert real coords to pixel coords for returned values */
  3127.  
  3128.   *xminp = (long)(xdmin * GZZWIDTH);
  3129.   *xmaxp = (long)(xdmax * GZZWIDTH);
  3130.   *yminp = (long)(ydmin * GZZWIDTH);
  3131.   *ymaxp = (long)(ydmax * GZZWIDTH);
  3132. }
  3133. /*===========================================================================*/
  3134.